Add files using upload-large-folder tool

parse/train/0WASBV4xkhy/0WASBV4xkhy.md

@@ -0,0 +1,361 @@
+# Towards a Theoretical Framework of Out-of-Distribution Generalization
+
+Chuanlong XieHuawei Noah’s Ark Labxie.chuanlong@huawei.com
+
+Haotian Ye   
+Peking University   
+Pazhou Lab   
+haotianye@pku.edu.cn
+
+Tianle Cai Peking University caitianle1998@pku.edu.cn
+
+# Ruichen Li
+
+# Zhenguo Li
+
+# Liwei Wang
+
+Peking University xk-lrc@pku.edu.cn
+
+Huawei Noah’s Ark Lab Li.Zhenguo@huawei.com
+
+Key Laboratory of Machine Perception, MOE, School of EECS, Institute for Artificial Intelligence, Peking University wanglw@cis.pku.edu.cn
+
+# Abstract
+
+Generalization to out-of-distribution (OOD) data is one of the central problems in modern machine learning. Recently, there is a surge of attempts to propose algorithms that mainly build upon the idea of extracting invariant features. Although intuitively reasonable, theoretical understanding of what kind of invariance can guarantee OOD generalization is still limited, and generalization to arbitrary out-of-distribution is clearly impossible. In this work, we take the first step towards rigorous and quantitative definitions of 1) what is OOD; and 2) what does it mean by saying an OOD problem is learnable. We also introduce a new concept of expansion function, which characterizes to what extent the variance is amplified in the test domains over the training domains, and therefore give a quantitative meaning of invariant features. Based on these, we prove OOD generalization error bounds. It turns out that OOD generalization largely depends on the expansion function. As recently pointed out by [21], any OOD learning algorithm without a model selection module is incomplete. Our theory naturally induces a model selection criterion. Extensive experiments on benchmark OOD datasets demonstrate that our model selection criterion has a significant advantage over baselines.
+
+# 1 Introduction
+
+One of the most fundamental assumptions of classic supervised learning is the “i.i.d. assumption”, which states that the training and the test data are independent and identically distributed. However, this assumption can be easily violated in a reality [8, 10, 11, 17, 38, 48, 56] where the test data usually have a different distribution than the training data. This motivates the research on the out-ofdistribution (OOD) generalization, or domain generalization problem, which assumes access only to data drawn from a set $\mathcal { E } _ { a v a i l }$ of available domains during training, and the goal is to generalize to a larger domain set ${ \mathcal { E } } _ { a l l }$ including unseen domains.
+
+To generalize to OOD data, most existing algorithms attempt to learn features that are invariant to a certain extent across training domains in the hope that such invariance also holds in unseen domains. For example, distributional matching-based methods [20, 35, 55] seek to learn features that have the same distribution across different domains; IRM [5] and its variants [1, 32, 33] learn feature representations such that the optimal linear classifier on top of the representation matches across domains.
+
+35th Conference on Neural Information Processing Systems (NeurIPS 2021).
+
+Though the idea of learning invariant features is intuitively reasonable, there is only limited theoretical understanding of what kind of invariance can guarantee OOD generalization. Clearly, generalization to an arbitrary out-of-distribution domain is impossible and in practice, the features can hardly be absolutely invariant from $\mathcal { E } _ { a v a i l }$ to ${ \mathcal { E } } _ { a l l }$ unless all the domains are identical. So it is necessary to first formulate what OOD data can be generalized to, or, what is the relation between the available training domain set $\mathcal { E } _ { a v a i l }$ and the entire domain set ${ \mathcal { E } } _ { a l l }$ . Meanwhile, to what extent the invariance of features on $\mathcal { E } _ { a v a i l }$ can be preserved in ${ \mathcal { E } } _ { a l l }$ should be rigorously characterized.
+
+In this paper, we take the first step towards a general OOD framework by quantitatively formalizing the relationship between $\mathcal { E } _ { a v a i l }$ and ${ \mathcal { E } } _ { a l l }$ in terms of the distributions of features and provide OOD generalization guarantees based on our quantification of the difficulty of OOD generalization problem. Specifically, we first rigorously formulate the intuition of invariant features used in previous works by introducing the “variation” and “informativeness” (Definition 3.1 and 3.2) of each feature. Our theoretical insight can then be informally stated as: for learnable OOD problems, if a feature is informative for the classification task as well as invariant over $\mathcal { E } _ { a v a i l }$ , then it is still invariant over ${ \mathcal { E } } _ { a l l }$ . In other words, invariance of informative features in $\mathcal { E } _ { a v a i l }$ can be preserved in ${ \mathcal { E } } _ { a l l }$ . We further introduce a class of functions, dubbed expansion function (Definition 3.3), to quantitatively characterize to what extent the variance of features on $\mathcal { E } _ { a v a i l }$ is amplified on ${ \mathcal { E } } _ { a l l }$ .
+
+Based on our formulation, we derive theoretical guarantees on the OOD generalization error, i.e., the gap of largest error between the domain in $\mathcal { E } _ { a v a i l }$ and domain in ${ \mathcal { E } } _ { a l l }$ . Specifically, we prove the upper and lower bound of OOD generalization error in terms of the expansion function and the variation of learned features over $\mathcal { E } _ { a v a i l }$ . Our results theoretically confirm that 1) the expansion function can reflect the difficulty of OOD generalization problem, i.e., problems with more rapidly increasing expansion functions are harder and have worse generalization guarantees; 2) the generalization error gap can tend to zero when the variation of learned features tend to zero, so minimizing the variation in $\mathcal { E } _ { a v a i l }$ can reduce the generalization error.
+
+As pointed out by Gulrajani and Lopez-Paz [21], any OOD algorithm without a specified model selection criterion is not complete. Since ${ \mathcal { E } } _ { a l l }$ is unseen, hyper-parameters can only be chosen according to $\mathcal { E } _ { a v a i l }$ . Previous selection methods mainly focus on validation accuracy over $\mathcal { E } _ { a v a i l }$ which is only a biased metric of OOD performance. On the contrary, a promising model selection method should instead be predictive of OOD performance. Inspired by our bounds, we propose a model selection method to select models with high validation accuracy and low variation, which corresponds to the upper bound of OOD error. The introduction of a model’s variation relieves the problem of classic selection methods, in which models that overfit $\mathcal { E } _ { a v a i l }$ tend to be selected. Experimental results show that our method can outperform baselines and select models with higher OOD accuracy.
+
+Contributions. We summarize our major contributions here:
+
+• We introduce a quantitative and rigorous formulation of OOD generalization problem that characterizes the relation of invariance over the training domain set $\mathcal { E } _ { a v a i l }$ and test domain set ${ \mathcal { E } } _ { a l l }$ . The core quantity in our characterization, the expansion function, determines the difficulty of an OOD generalization problem.
+
+• We prove novel OOD generalization error bounds based on our formulation. The upper and lower bounds together indicate that the expansion function well characterizes the OOD generalization ability of features with different levels of variation.
+
+• We design a model selection criterion that is inspired by our generalization bounds. Our criterion takes both the performance on training domains and the variation of models into consideration and is predictive of OOD performance according to our bounds. Experimental results demonstrate our selection criterion can choose models with higher OOD accuracy.
+
+The rest of the paper is organized as follows: Section 2 is our preliminary. In Section 3, we give our theoretical formulation. Section 4 gives our generalization bound. We propose our model selection method in Section 5. In Section 6 we conduct experiments on expansion function and model selection. We review more related works in Section 7 and conclude our work in Section 8.
+
+# 2 Preliminary
+
+Throughout the paper, we consider a multi-class classification task $\mathcal { X } \to \mathcal { Y } = \{ 1 , . . . , K \}$ .1 Let ${ \mathcal { E } } _ { a l l }$ be the domain set we want to generalize to, and $\mathcal { E } _ { a v a i l } \subseteq \mathcal { E } _ { a l l }$ be the available domain set, i.e., all domains we have during the training procedure. We denote $( X ^ { e } , Y ^ { e } )$ to be the input-label pair drawn from the data distribution of domain $e$ . The OOD generalization goal is to find a classifier $f ^ { * }$ that minimizes the worst-domain loss on ${ \mathcal { E } } _ { a l l }$ :
+
+$$
+f ^ { * } = \underset { f \in \mathcal { F } } { \mathrm { a r g m i n } } \mathcal { L } ( \mathcal { E } _ { a l l } , f ) , \mathcal { L } ( \mathcal { E } , f ) \triangleq \underset { e \in \mathcal { E } } { \mathrm { m a x } } \mathbb { E } \big [ \ell \big ( f ( X ^ { e } ) , Y ^ { e } \big ) \big ]
+$$
+
+where $\mathcal { F } : \mathcal { X } \xrightarrow { } \mathbb { R } ^ { K }$ is the the hypothetical space and $\ell ( \cdot , \cdot )$ is a loss function. Similar to previous works [5, 16, 27, 33], we assume that $f$ can be decomposed into $g \circ h$ , where $g \in \mathcal { G } : \mathbb { R } ^ { d }  \mathbb { R } ^ { K }$ is the top classifier and $h : \mathcal { X }  \mathbb { R } ^ { d }$ is a $d$ -dimensional feature extractor, i.e.,
+
+$$
+h ( x ) = ( \phi _ { 1 } ( x ) , \phi _ { 2 } ( x ) , \ldots , \phi _ { d } ( x ) ) ^ { \top } , \quad \phi _ { i } \in \Phi .
+$$
+
+Here $\Phi$ is the set of scalar feature maps which map $\mathcal { X }$ to $\mathbb { R }$ and $d$ is fixed. We will call each $\phi \in \Phi$ a feature for simplicity. Given a domain $e$ , we denote the $d$ -dimensional random vector $h ( X ^ { e } )$ as $h ^ { e }$ , one-dimensional feature $\phi ( X ^ { e } )$ as $\phi ^ { e }$ , and the conditional distribution of $h ^ { e } , \phi ^ { e }$ given $Y ^ { e } = y$ as $\mathbb { P } ( h ^ { e } | y ) , \mathbb { P } ( \phi ^ { e } | y )$ . For simplicity, we assume the data distribution is balanced in every domain, i.e., $P ( Y ^ { e } = y ) = \frac { 1 } { K } , \forall y \in \mathcal { Y } , e \in \mathcal { E } _ { a l l }$ . Our framework can be easily extended to the case where the balanced assumption is removed, with an additional term corresponding to the imbalance adding to the generalization bounds.
+
+# 3 Framework of OOD Generalization Problem
+
+The main challenge of formalizing the OOD generalization problem is to mathematically describe the connection between $\mathcal { E } _ { a v a i l }$ and ${ \mathcal { E } } _ { a l l }$ and how generalization depends on this relation. Towards this goal, we introduce several quantities to characterize the relation of feature distributions over different domains and bridge $\mathcal { E } _ { a v a i l }$ and ${ \mathcal { E } } _ { a l l }$ by expansion function (Definition 3.3) over the quantities we have introduced. Our framework is motivated by the understanding that, in an OOD generalization task, certain “property” of “good” features in $\mathcal { E } _ { a v a i l }$ should be “preserved” in ${ \mathcal { E } } _ { a l l }$ (the reason is described in Section 1). In Section 3.1, we will go into details on what we mean by “property” (variation, Definition 3.1), “good” (informativeness, Definition 3.2), and “preserved” (measured by expansion function). In Section 6.2, we further illustrate the key concepts in our framework by a real-world OOD problem.
+
+# 3.1 Formalizing OOD Problem by Quantifying Feature Distribution
+
+We first introduce the concepts “variation" and “informativeness" of a feature $\phi$ . The first one is what we expect to be preserved in ${ \mathcal { E } } _ { a l l }$ and the second one characterizes what features will be considered. Specifically, let $\rho ( \mathbb { P } , \mathbb { Q } )$ be a symmetric “distance” of two distributions. Note that $\rho$ can have many choices, like $L _ { 2 }$ Distance, Total Variation and symmetric KL-divergence, etc. The variation and informativeness are defined as follows:
+
+Definition 3.1 (Variation). The variation of feature $\phi ( \cdot )$ across a domain set $\mathcal { E }$ is
+
+$$
+\mathcal { V } _ { \rho } ( \phi , \mathcal { E } ) = \operatorname* { m a x } _ { y \in \mathcal { V } } \operatorname* { s u p } _ { e , e ^ { \prime } \in \mathcal { E } } \rho \big ( \mathbb { P } ( \phi ^ { e } | y ) , \mathbb { P } ( \phi ^ { e ^ { \prime } } | y ) \big ) .
+$$
+
+A feature $\phi ( \cdot )$ is $\varepsilon$ -invariant across $\mathcal { E }$ , $i f \varepsilon \geq \mathcal { V } ( \phi , \mathcal { E } )$ (We omit the subscript $\rho$ in case of no ambiguity). Definition 3.2 (Informativeness). The informativeness of feature $\phi ( \cdot )$ across a domain set $\mathcal { E }$ is
+
+$$
+\mathcal { T } _ { \rho } ( \phi , \mathcal { E } ) = \frac { 1 } { K ( K - 1 ) } \sum _ { \stackrel { y \neq y ^ { \prime } } { y , y ^ { \prime } \in y } } \operatorname* { m i n } _ { e \in \mathcal { E } } \rho \big ( \mathbb { P } ( \phi ^ { e } | y ) , \mathbb { P } ( \phi ^ { e } | y ^ { \prime } ) \big ) .
+$$
+
+A feature $\phi ( \cdot )$ is $\delta$ -informative across $\varepsilon$ , if $\quad \delta \leq { \mathcal { I } } ( \phi , { \mathcal { E } } )$ .
+
+The variation $\mathcal { V } ( \phi , \mathcal { E } )$ measures the stability of $\phi ( \cdot )$ over the domains in $\mathcal { E }$ and the informativeness ${ \mathcal { T } } ( \phi , { \mathcal { E } } )$ captures the ability of $\phi ( \cdot )$ to distinguish different labels. We would like to highlight that the variation and informativeness are defined on each one-dimensional feature $\phi ( \cdot )$ . Unlike previous distance between distributions defined in $d$ -dimensional space, our definitions are more reasonable and practical, since it can be easily calculated and analyzed.
+
+We are now ready to introduce the core quantity for connecting $\mathcal { E } _ { a v a i l }$ and ${ \mathcal { E } } _ { a l l }$ . Our motivation, as elaborated in the introduction section, is that, if a feature is informative for the classification task and invariant over $\mathcal { E } _ { a v a i l }$ , then to enable OOD generalization from $\mathcal { E } _ { a v a i l }$ to ${ \mathcal { E } } _ { a l l }$ , it should be still invariant over ${ \mathcal { E } } _ { a l l }$ . So the relation between $\mathcal { V } ( \phi , \mathcal { E } _ { a v a i l } )$ and $\mathinner { \gamma \mathopen { \left( \phi , \mathcal { E } _ { a l l } \right) } }$ of an informative feature captures the feasibility and difficulty of OOD generalization. To quantitatively measure this relation, we define the following function class:
+
+Definition 3.3 (Expansion Function). We say a function $s : \mathbb { R } ^ { + } \cup \{ 0 \}  \mathbb { R } ^ { + } \cup \{ 0 , + \infty \}$ is an expansion function, iff the following properties hold: 1) $s ( \cdot )$ is monotonically increasing and $s ( x ) \geq x , \forall x \geq 0 ; 2 ,$ ) $\begin{array} { r } { \operatorname* { l i m } _ { x  0 ^ { + } } s ( x ) = s ( 0 ) = 0 } \end{array}$ .
+
+This function class gives a full characterization of how the variation between $\mathcal { E } _ { a v a i l }$ and ${ \mathcal { E } } _ { a l l }$ is related. Based on this function class, we can introduce our formulation of the learnability of OOD generalization as follows:
+
+Definition 3.4 (Learnability). Let $\Phi$ be the feature space and $\rho$ be a distribution distance. We say an OOD generalization problem from $\mathcal { E } _ { a v a i l }$ to ${ \mathcal { E } } _ { a l l }$ is learnable if there exists an expansion function $s ( \cdot )$ and $\delta \geq 0$ , such that: for all $\phi \in \Phi$ satisfying ${ \mathcal { T } } _ { \rho } ( \phi , { \mathcal { E } } _ { a v a i l } ) \geq \delta$ , we have $s ( \mathcal { V } _ { \rho } ( \phi , \mathcal { E } _ { a v a i l } ) ) \geq$ $\mathcal { V } _ { \rho } \big ( \phi , \mathcal { E } _ { a l l } \big )$ . If such $s ( \cdot )$ and $\delta$ exist, we further call this problem $( s ( \cdot ) , \delta )$ -learnable. If an $o o D$ generalization problem is not learnable, we call $i t$ unlearnable.
+
+To understand the intuition and rationality of our formulation, several discussions are in order.
+
+Properties of the expansion function. In Definition 3.3, we highlight two properties of the expansion function. The first property comes naturally from the monotonicity properties of variation: any $\varepsilon _ { 1 }$ -invariant feature is also $\varepsilon _ { 2 }$ -invariant for $\varepsilon _ { 2 } \geq \varepsilon _ { 1 }$ ; and $\mathcal { V } ( \phi , \mathcal { E } _ { 1 } ) \leq \mathcal { V } ( \phi , \mathcal { E } _ { 2 } )$ for any ${ \mathcal { E } } _ { 1 } \subseteq { \mathcal { E } } _ { 2 }$ . The monotonicity also implies that larger ${ \mathcal { E } } _ { a l l }$ will induce larger $s ( \cdot ) ^ { 2 }$ and it is also harder to be generalized to. From this view, we can see that the scale of $s ( \cdot )$ can reflect the difficulty of OOD generalization. The second property is more crucial since it formulates the intuition that if an informative feature is almost invariant in $\mathcal { E } _ { a v a i l }$ , it should remain invariant in ${ \mathcal { E } } _ { a l l }$ . Without this assumption, OOD generalization can never be guaranteed because we cannot predict whether an invariant and informative feature in $\mathcal { E } _ { a v a i l }$ will vary severely in unseen ${ \mathcal { E } } _ { a l l }$ .
+
+Necessity of informativeness. We include a seemingly redundant quantity informativeness in the definition of learnability. However, this term is necessary because only informative features are responsible for the performance of classification. Non-informative but invariant features over $\mathcal { E } _ { a v a i l }$ may only capture some noise that is irrelevant to the classification problem, and we shall not expect the noise to be invariant over ${ \mathcal { E } } _ { a l l }$ . Moreover, we show in Figure 1 that in practice, many invariant but useless features in $\mathcal { E } _ { a v a i l }$ vary a lot in ${ \mathcal { E } } _ { a l l }$ , and adding the constraint of informativeness makes the expansion function reasonable. In addition, there are multiple choices of $( s ( \cdot ) , \delta )$ to make an OOD generalization problem learnable: larger $\delta$ will filter out more features, and so $\dot { s } ( \cdot )$ can be smaller (flatter). This multiplicity will result in a trade-off between $s ( \cdot )$ and $\delta$ , which will be discussed in Section 6.2.
+
+Two extreme cases: i.i.d. & unlearnable. To better understand the concept of learnability, we consider two extreme cases. (1) The first example is when all data from different $\textit { e } \in \mathcal { E } _ { a l l }$ are identically distributed, i.e., the classic supervised learning setting. This problem is $( s ( \cdot ) , 0 )$ -learnable with $s ( x ) = x$ , implying no extra difficulty in OOD generalization. (2) As an example of unlearnable, consider the following case (modified from Colored MNIST [5]): For $e \in \mathcal { E } _ { a v a i l }$ , images with label 0 always has a red background while images with label 1 has a blue background. For $e \in \mathcal { E } _ { a l l } \ \backslash \ \mathcal { E } _ { a v a i l }$ , this relationship is entirely inverse. Since data from different $e \in \mathcal { E } _ { a v a i l }$ are identically distributed but different from other $e \in \mathcal { E } _ { a l l }$ , no expansion function can make it learnable, i.e., it is OOD-unlearnable.
+
+The unlearnability of this case also coincides with our intuition: Without prior knowledge, it is not clear from merely the training data, whether the task is to distinguish digit 0 from 1, or to distinguish color red from blue. As a result, generalization to ${ \mathcal { E } } _ { a l l }$ cannot be guaranteed.
+
+# 4 Generalization Bound
+
+In this section, we consider an OOD generalization problem from $\mathcal { E } _ { a v a i l }$ to ${ \mathcal { E } } _ { a l l }$ , and our goal is to analyze the OOD generalization error of classifier $f = g \circ h$ defined by
+
+$$
+\mathrm { e r r } ( f ) = \mathcal { L } ( \mathcal { E } _ { a l l } , f ) - \mathcal { L } ( \mathcal { E } _ { a v a i l } , f ) ,
+$$
+
+where we assume the loss function $l ( \cdot , \cdot )$ is bounded by $[ 0 , C ]$ . We prove two upper bounds (4.1, 4.2) as well as a lower bound (4.3) for $\operatorname { e r r } ( f )$ based on our formulation. Our bounds together provide a complete characterization of the difficulty of OOD generalization. Since we expect that an invariant classifier can generalize to unseen domains, we hope to bound $\operatorname { e r r } ( f )$ in terms of the certain variation of $f$ . To this end, we define the variation and informativeness of $f$ in terms of its features, i.e.,
+
+$$
+\begin{array} { r l r } { \mathcal { V } ^ { \operatorname* { s u p } } ( h , \mathcal { E } _ { a v a i l } ) } & { \triangleq } & { \underset { \beta \in S ^ { d - 1 } } { \operatorname* { s u p } } \mathcal { V } ( \beta ^ { \top } h , \mathcal { E } _ { a v a i l } ) , } \\ { \mathcal { T } ^ { \operatorname* { i n f } } ( h , \mathcal { E } _ { a v a i l } ) } & { \triangleq } & { \underset { \beta \in S ^ { d - 1 } } { \operatorname* { i n f } } \mathcal { T } ( \beta ^ { \top } h , \mathcal { E } _ { a v a i l } ) , } \end{array}
+$$
+
+where $( \beta ^ { \top } h ) ( x ) = \beta ^ { \top } h ( x )$ is a feature and $S ^ { d - 1 } = \{ \beta \in \mathbb { R } ^ { d } : \| \beta \| _ { 2 } = 1 \}$ is the unit $( d - 1 )$ -sphere.
+
+Necessity of using supremum over linear combination. One seemingly plausible definition of the variation of a classifier $f$ can be the supremum over all $\mathcal { V } ( \phi _ { i } , \mathcal { E } _ { a v a i l } ) , i \in [ d ]$ . However, as is shown in Appendix 1, it is possible that two high-dimensional joint distributions have close marginal distribution in each dimension, while they do not overlap. In other words, there exist cases where $\mathcal { V } ( \phi _ { i } , \mathcal { E } _ { a l l } ) = 0 , \forall i \in [ d ]$ but after applying the top model $g$ over $\phi _ { i }$ ’s, the distribution varies a lot in $\mathcal { E } _ { a v a i l }$ . Our definition comes from the simple idea that the class of top model $\mathcal { G }$ is at least a linear space, so we should at least consider the variation of every (normalized) linear combination of $h ( \cdot )$ With this, we can guarantee the joint distribution distance is still small.
+
+Theorem 4.1 (Main Theorem). Suppose we have learned a classifier $f ( x ) = g ( h ( x ) )$ such that $\forall e \in \mathcal { E } _ { a l l }$ and $\forall y \in \mathcal { V } ;$ $, p _ { h ^ { e } | Y ^ { e } } ( h | y ) \in L ^ { 2 } ( \mathbb R ^ { d } )$ . Denote the characteristic function of random variable $h ^ { e } | Y ^ { e }$ as $\hat { p } _ { h ^ { e } | Y ^ { e } } ( t | y ) = \mathbb { E } [ \exp \{ i \langle t , h ^ { e } \rangle \} | Y ^ { e } = y ]$ . Assume the hypothetical space $\mathcal { F }$ satisfies the following regularity conditions that $\exists \alpha , M _ { 1 } , M _ { 2 } > 0 , \forall f \in \mathcal { F } , \forall e \in \mathcal { E } _ { a l l } , y \in \mathcal { V }$ ,
+
+$$
+\int _ { h \in \mathbb { R } ^ { d } } p _ { h ^ { e } | Y ^ { e } } ( h | y ) | h | ^ { \alpha } \mathrm { d } h \leq M _ { 1 } \quad a n d \quad \int _ { t \in \mathbb { R } ^ { d } } | \hat { p } _ { h ^ { e } | Y ^ { e } } ( t | y ) | | t | ^ { \alpha } \mathrm { d } t \leq M _ { 2 } .
+$$
+
+$I f ( \mathcal { E } _ { a v a i l } , \mathcal { E } _ { a l l } )$ is $\left( s ( \cdot ) , \mathcal { T } ^ { i n f } ( h , \mathcal { E } _ { a v a i l } ) \right)$ -learnable under $\Phi$ with Total Variation $\rho ^ { 3 }$ , then we have
+
+$$
+\operatorname { e r r } ( f ) \leq O \left( s \left( \mathcal { V } _ { \rho } ^ { s u p } ( h , \mathcal { E } _ { a v a i l } ) \right) ^ { \frac { \alpha ^ { 2 } } { ( \alpha + d ) ^ { 2 } } } \right) .
+$$
+
+Here $\rho$ is total variation distance, and $O ( \cdot )$ depends on $d , C , \alpha , M _ { 1 } , M _ { 2 }$ .
+
+The above theorem holds for a general classifier learned by any algorithms. Due to its generality, we need to introduce some technical regularity conditions on the density function. The assumption (4) assume the decay rate of density and its characteristic function, which is common in the literature, e.g. [14]. This theorem demonstrates that, the generalization error can be bounded by a function of the variation of $h$ , and it converges to 0 as the variation approaches to 0. Under some special but typical case where the top model $g$ is linear, we can further show that even without the regularity conditions in Theorem 4.1, we have a much better (linear) convergence rate.
+
+Theorem 4.2 (Linear Top Model). Consider any loss satisfying $\begin{array} { r } { \ell ( \hat { y } , y ) = \sum _ { k = 1 } ^ { K } \ell _ { 0 } ( \hat { y } _ { k } , y _ { k } ) } \end{array}$ .4 For any classifier with linear top model $g$ , i.e.,
+
+$$
+f ( x ) = A h ( x ) + b w i t h A \in \mathbb { R } ^ { K \times d } , b \in \mathbb { R } ^ { K } ,
+$$
+
+$i f ( \mathcal { E } _ { a v a i l } , \mathcal { E } _ { a l l } )$ is $\left( s ( \cdot ) , \mathcal { T } ^ { i n f } ( h , \mathcal { E } _ { a v a i l } ) \right)$ -learnable under $\Phi$ with Total Variation $\rho$ , then we have
+
+$$
+\mathrm { e r r } ( f ) \leq O \Bigl ( s \bigl ( \mathcal { V } ^ { s u p } ( h , \mathcal { E } _ { a v a i l } ) \bigr ) \Bigr ) .
+$$
+
+Here $O ( \cdot )$ depends only on d and $C$ .
+
+Discussion. Theorem 4.1 shows that, for any model, the generalization gap depends largely on the model’s variation captured by $\mathcal { V } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } )$ . The result is irrelevant to the algorithm and provides a guarantee for the generalization gap from $\mathcal { E } _ { a v a i l }$ to ${ \mathcal { E } } _ { a l l }$ , so long as the learned model $f$ is invariant, i.e. $\mathcal { V } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } )$ is small. When $s ( \cdot )$ is fixed, a model with smaller $\mathcal { V } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } )$ results in a smaller gap, which matches our understanding that invariant features in $\mathcal { E } _ { a v a i l }$ are somehow invariant in ${ \mathcal { E } } _ { a l l }$ . When $\mathcal { V } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } )$ is fixed, more difficult generalization will generate a larger expansion function, which leads to a larger gap. For the Gaussian class with bounded mean and variance, $\alpha \gg d$ and the convergent rate is almost linear.
+
+However, without any constraint to $g$ , the convergent rate might be small. Theorem 4.2 then offers a generalization bound with a linear convergent rate under mild assumptions when $g$ is linear, which is common in reality. It relaxes the concentration assumption (Formula 4) and asks only for the integrability of the density. The convergent rate is identical to the convergent rate of the expansion function, showing that $s ( \cdot )$ captures the generalization quite well.
+
+Proof Sketch of Theorem 4.1. The proof of the main result, Theorem 4.1, is decomposed into the following steps. First, we transform $\operatorname { e r r } ( f )$ into the Total Variation of joint distributions of features in different domains (Step 1). To bound the Total Variation, it is sufficient to bound the distance of the corresponding Fourier transform, and further, it is equivalent to bound the Radon transform of joint distributions (Step 2). Eventually, we show that $\mathcal { V } ^ { \mathrm { s u p } } ( \beta ^ { \top } h , \mathcal { E } _ { a v a i l } )$ can be used to bound the Radon transform, which finishes the proof (Step 3).
+
+Step 1. The OOD generalization error can be bounded as:
+
+$$
+\mathrm { e r r } ( f ) \le \operatorname* { s u p } _ { ( e , e ^ { \prime } ) \in ( \mathcal { E } _ { a v a i l } , \mathcal { E } _ { a l l } ) } \frac { C } { K } \sum _ { y \in \mathcal { Y } } \int _ { h \in \mathbb { R } ^ { d } } \big | p _ { h ^ { e } | Y ^ { e } } ( h | y ) - p _ { h ^ { e ^ { \prime } } | Y ^ { e ^ { \prime } } } ( h | y ) ) \big | \mathrm { d } h .
+$$
+
+Step 2. According to the assumption (4), the dominant term in (7) is
+
+$$
+\int _ { | h | \leq r _ { 1 } } \Big | \int _ { | t | \leq r _ { 2 } } e ^ { - i \langle h , t \rangle } \big ( \hat { p } _ { h ^ { e } | Y ^ { e } } ( t | y ) - \hat { p } _ { h ^ { e ^ { \prime } } | Y ^ { e ^ { \prime } } } ( t | y ) \big ) \big ) \mathrm { d } t \Big | \mathrm { d } t ,
+$$
+
+where $r _ { 1 }$ and $r _ { 2 }$ are well-selected scalars that depend on $s \big ( \mathcal { V } _ { \rho } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } ) \big )$ . By the Projection Theorem [31, 42] and the Fourier Inversion Formula, (8) is bounded above by
+
+$$
+O ( r _ { 1 } ^ { d } r _ { 2 } ^ { d } ) \times \int _ { u \in \mathbb { R } } \big | \mathscr { R } _ { e ^ { \prime } } ( \beta , u ) - \mathscr { R } _ { e } ( \beta , u ) \big | \mathrm { d } u ,
+$$
+
+where $\mathcal { R } _ { e } ( \beta , u )$ is the Radon transform of $p _ { h ^ { e } | Y ^ { e } } ( t | y )$ .
+
+Step 3. The right-hand side of Formula 8 can be bounded by $O \big ( r _ { 1 } ^ { d } r _ { 2 } ^ { d } s \big ( \mathcal { V } _ { \rho } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } ) \big ) \big )$ . We finish the proof by selecting appropriate $r _ { 1 }$ and $r _ { 2 }$ to balance the rate of the dominant term and other minor terms. For more details, please see Appendix 2 for the complete proofs.
+
+Now we turn to the lower bound of $\operatorname { e r r } ( f )$
+
+Theorem 4.3 (Lower Bound). Consider 0-1 loss: $\ell ( \hat { y } , y ) = \mathbb { I } ( \hat { y } \neq y )$ . For any $\delta > 0$ and any exps.t. $k x \leq s ( x ) < + \infty , x \in [ 0 , t ]$ $\begin{array} { r } { s _ { + } ^ { \prime } ( 0 ) \triangleq \operatorname* { l i m } _ { x \to 0 ^ { + } } \frac { s ( x ) - s ( 0 ) } { x } \in ( 1 , + \infty ) } \end{array}$ s(x)−s(0) ∈ (1, +∞); 2) exists k > 1, t > 0, $C _ { 0 }$ $O O D$ generaliz $( \mathcal { E } _ { a v a i l } , \mathcal { E } _ { a l l } )$ that is $( s ( \cdot ) , \delta )$ -learnable under linear feature space $\Phi$ w.r.t symmetric $K L$ -divergence $\rho$ , s.t. $\forall \varepsilon \ \in \ [ 0 , \frac { t } { 2 } ] .$ , the optimal classifier $f$ satisfying $\mathcal { V } ^ { s u p } ( h , \mathcal { E } _ { a v a i l } ) = \varepsilon$ will have the OOD generalization error lower bounded by
+
+$$
+\mathrm { e r r } ( f ) \geq C _ { 0 } \cdot s ( \mathcal { V } ^ { s u p } ( h , \mathcal { E } _ { a v a i l } ) ) .
+$$
+
+Theorem 4.3 shows that $\operatorname { e r r } ( f )$ of optimal classifier $f$ is lower bounded by its variation. Here “optimal” means the classifier that minimize $\mathcal { L } ( f , \mathcal { E } _ { a v a i l } )$ . Altogether, the above three theorems offer a bidirectional control of OOD generalization error, showing that our formulation can offer a fine-grained description of most OOD generalization problem in a theoretical way. To pursue a good OOD performance, OOD algorithm should focus on improving predictive performance on $\mathcal { E } _ { a v a i l }$ and controlling the variation $\mathcal { V } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } )$ simultaneously. Note that this bound starts from population error, and we call for future works to combine our generalization bound and traditional bound from data samples to population error, giving a more complete characterization of the problem.
+
+# 5 Variation as a Factor of Model Selection Criterion
+
+As is pointed out in [21], model selection has a significant effect on domain generalization, and any OOD algorithm without a model selection criterion is not complete. [21] trained more than 45,900 models with different algorithms, and results show that when traditional selection methods are applied, none of OOD algorithms can outperform ERM [58] by a significant margin. This result is not strange, since traditional selection methods focus mainly on (validation) accuracy, which is biased in OOD generalization [21, 63]. A very typical example is Colored MNIST [5], where the image is colored according to the label, but the relationship varies across domains. As explained in [5], ERM principle will only capture this spurious feature (color) and performs badly in ${ \mathcal { E } } _ { a l l }$ . Since ERM is exactly minimizing loss in $\mathcal { E } _ { a v a i l }$ , any model selection method using validation accuracy alone is likely to choose ERM rather than any other OOD algorithm [63]. Thus no algorithm will have a significant improvement compared to ERM.
+
+A natural question arises: what else can we use, in addition to accuracy? Theorem 4.1 points out that, learning feature with small variation across $\mathcal { E } _ { a v a i l }$ is important for decreasing OOD generalization error. Once a model $f$ achieves a small $\mathcal { V } ^ { \mathrm { s u p } } ( h , \mathcal { E } _ { a v a i l } )$ , then $\operatorname { e r r } ( f )$ will be small. If the validation accuracy is also high, we shall know that the OOD accuracy will remain high. To this end, we propose our heuristic selection criterion (Algorithm 1). Instead of considering validation accuracy alone, we combine it with feature variation and select the model with high validation accuracy as well as low variation.
+
+# Algorithm 1: Model Selection
+
+Input: available dataset $\mathcal { X } _ { a v a i l } = ( \mathcal { X } _ { t r a i n } , \mathcal { X } _ { v a l } )$ , candidate models set $\mathcal { M }$ , var_acc_rate $r _ { 0 }$ .   
+for $f = g \circ h$ in $\mathcal { M }$ do for $i$ in $[ d ]$ do $\hat { \mathcal { V } } _ { i } \gets \operatorname* { m a x } _ { y \in \mathcal { V } , \mathcal { X } ^ { e } \neq \mathcal { X } ^ { e ^ { \prime } } \in \mathcal { X } _ { a v a i l } }$ Total Variation $( \mathbb { P } ( \phi _ { i } ^ { e } | y ) , \mathbb { P } ( \phi _ { i } ^ { e ^ { \prime } } | y ) )$ ; .Use GPU KDE end $\mathcal { V } _ { f } \gets \mathrm { m e a n } _ { i \in [ d ] } \hat { \mathcal { V } } _ { i }$ $\operatorname { A c c } _ { f } $ compute validation accuracy of $f$ using $\mathcal { X } _ { v a l }$   
+end   
+Retur ${ \mathfrak { n } } \operatorname { a r g m a x } _ { f \in { \mathcal { M } } } ( \operatorname { A c c } _ { f } - r _ { 0 } \mathcal { V } _ { f } )$
+
+We briefly explain Algorithm 1 here. For each candidate model, we calculate its variation using the average of each feature’s variation, i.e., $\begin{array} { r } { \frac { 1 } { d } \sum _ { i \in [ d ] } \mathcal { V } ( \phi _ { i } , \mathcal { X } _ { a v a i l } ) } \end{array}$ . When deriving the bounds, we use $\mathcal { V } ^ { \mathrm { s u p } }$ instead of their average because we need to consider the worst case, i.e., the worst top model. In practice, we find out that the average of $\mathcal { V } ( \phi _ { i } , \mathcal { X } _ { a v a i l } )$ is enough to improve selection.
+
+Our criterion of model selection is
+
+$$
+\operatorname { A c c } _ { f } { - r _ { 0 } \gamma _ { f } } ,
+$$
+
+i.e., we select a model with high validation accuracy and low variation simultaneously. Here $r _ { 0 }$ is a hyper-parameter representing the concrete relationship between $\operatorname { e r r } ( f )$ and $\mathcal { V } _ { f }$ . Although we have already used one hyper-parameter to help select multiple hyper-parameter combinations, it is natural to ask whether we can further get rid of the selection of $r _ { 0 }$ . Since $r _ { 0 }$ represents the relationship between variation and accuracy, which is actually determined by the unknown expansion function, explicitly calculating $r _ { 0 }$ is not possible. However, we can empirically estimate $r _ { 0 }$ using $\begin{array} { r } { r _ { 0 } = \frac { \mathrm { S t d } _ { f \in \hat { \mathcal { M } } } \mathrm { A c c } _ { f } } { \mathrm { S t d } _ { f \in \hat { \mathcal { M } } } \mathcal { V } _ { f } } } \end{array}$ where $\hat { \mathcal { M } } \subset \mathcal { M }$ is the model with not bad validation accuracy. We do not use the whole set $\mathcal { M }$ because some OOD algorithms will perform extremely bad when the penalty is huge, and these models will influence our estimation of the ratio. Since high validation means large informativeness in learned features, the use of $\hat { \mathcal { M } }$ is an implicit application of informative assumption.
+
+As shown in Section 6.1, our method can select models with higher OOD accuracy in various OOD datasets. We also explain in Appendix 3 why our method can outperform the traditional method in Color MNIST, where the dataset is hand-make and simple enough to calculate the expansion function.
+
+# 6 Experiments
+
+In this section, we conduct experiments to compare our model selection criterion (Section 5) with the baseline method5 [21]. Since both the variation and informativeness in Definition 3.1 are based on one-dimensional features, we can directly estimate these quantities feature-by-feature and design model selection method based on them. To verify the existence of the expansion function and to see what it’s like in a real-world dataset, we plot nearly 2 million features trained in a common-used OOD dataset and compute their variation and informativeness. We then draw the expansion function for this problem.
+
+# 6.1 Experiments on Model Selection
+
+In this section, we conduct experiments to compare the performance of models selected by our method and by validation accuracy. We train models on different datasets, different $\mathcal { E } _ { a v a i l }$ , and select models according to a different selection criteria. We then compare the OOD accuracy of selected models.
+
+Settings We train our model on three benchmark OOD datasets (PACS [34], OfficeHome [59], VLCS [57]) and consider all possible selections of $( \mathcal { E } _ { a v a i l } , \mathcal { E } _ { a l l } )$ . We choose ResNet–50 as our network architecture. We use ERM [58] and four common-used OOD algorithms (CORAL [55], Inter-domain Mixup [62], Group DRO [51], and IRM [5]). For each environment setup, we train 200 models using different algorithms, penalties, learning rates, and epoch. After training, we employ different selection methods and compare the OOD accuracy of the selected models. As stated in Section 5, we use the standard deviation of $\nu$ and validation accuracy in $\hat { \mathcal { M } }$ to estimate $r _ { 0 }$ , where ${ \hat { \mathcal { M } } } = \{ f \in { \mathcal { M } } : \operatorname { A c c } _ { f } \geq \operatorname* { m a x } _ { \hat { f } } \operatorname { A c c } _ { \hat { f } } - 0 . 1 \}$ . Note that calculating $\mathcal { V } ( \phi _ { i } , \mathcal { X } _ { a v a i l } )$ takes calculus many times, so we design a parallel GPU kernel density estimation to speed up the whole process a hundred times and manage to finish one model in seconds. For more details about the experiments, see Appendix 4.
+
+Table 1: Model Selection Result. “Env” denotes the unseen domain during training. “Val” denotes the OOD accuracy of model selected by validation accuracy.   
+
+<table><tr><td rowspan="3">PACS</td><td>Env</td><td>A</td><td>C</td><td>P</td><td>S</td><td>avg</td><td>acc inc</td></tr><tr><td>Val</td><td>85.20%</td><td>80.42%</td><td>96.17%</td><td>77.86%</td><td>84.91%</td><td>1</td></tr><tr><td>Ours</td><td>88.72%</td><td>81.74%</td><td>96.83%</td><td>79.00%</td><td>86.57%</td><td>1.66%↑</td></tr><tr><td rowspan="3">OfficeHome</td><td>Env</td><td>A</td><td>C</td><td>P</td><td>R</td><td>avg</td><td>acc inc</td></tr><tr><td>Val</td><td>61.85%</td><td>55.56%</td><td>74.72%</td><td>76.25%</td><td>67.09%</td><td>-</td></tr><tr><td>Ours</td><td>65.76%</td><td>55.07%</td><td>75.20%</td><td>76.31%</td><td>68.09%</td><td>1.00%↑</td></tr><tr><td rowspan="3">VLCS</td><td>Env</td><td>C</td><td>L</td><td>S</td><td>V</td><td>avg</td><td>acc inc</td></tr><tr><td>Val</td><td>97.46%</td><td>64.83%</td><td>69.50%6</td><td>70.97%</td><td>75.69%</td><td>1</td></tr><tr><td>Ours</td><td>97.81%</td><td>66.98%</td><td>69.50%</td><td>70.97%</td><td>76.32%</td><td>0.63%↑</td></tr></table>
+
+Result We summarize our experimental results in Table 1. For each environment setup, we select the best model according to Algorithm 1 and validation accuracy. The results show that on all datasets, our selection criterion significantly outperforms the validation accuracy in average OOD accuracy. For a more detailed comparison, our method improves the OOD accuracy in most of the 12 setups. Our experiments demonstrate that our criterion can help select models with higher OOD accuracy.
+
+![](images/c514b7d4698237506faccba2638407d1bd68cc2a61ac79a424f03d7abc31b464.jpg)  
+Figure 1: The expansion function of the OOD generalization problem on Office-Home. The $\mathbf { X } ^ { } -$ -axis stands for $\mathcal { V } ( \phi , \mathcal { E } _ { a v a i l } )$ and the y-axis for $\mathcal { V } ( \phi , \mathcal { E } _ { a l l } )$ . There are approximately 2 million points in each image, with each point representing a feature, and its color represents its informativeness. The solid red line stands for the expansion function under the corresponding $\delta$ . When $\delta$ increases, the expansion function decreases. When $\delta = 0$ , no expansion function can make it learnable.
+
+One may wonder if the expansion function really exists and what it will look like for a real-world OOD generalization task. In this section, we consider the OOD dataset Office-Home [59]. We explicitly plot millions of features’ $\mathcal { V } _ { \rho } \big ( \phi , \mathcal { E } _ { a v a i l } \big )$ and $\mathcal { V } _ { \rho } \big ( \phi , \mathcal { E } _ { a l l } \big )$ with Total Variation $\rho$ to see what the expansion function is like in this task. We take the architecture as ResNet-50 [23], and we trained thousands of models with more than five algorithms, obtaining about 2 million features. The results are in Figure 1.
+
+Existence of $s ( \cdot )$ . When $\delta = 0$ , some non-informative features are nearly 0-invariant across $\mathcal { E } _ { a v a i l }$ but are varying across ${ \mathcal { E } } _ { a l l }$ , so no expansion function can make this task learnable, i.e., this task is NOT $( s ( \cdot ) , 0 )$ for any expansion function. But as $\delta$ increases, only informative features are left, and now we can find appropriate $s ( \cdot )$ to make it learnable. We can clearly realize from the figure that $s ( \cdot )$ do exist when $\delta \geq 0 . 1 5$ .
+
+Trade-off between $s ( \cdot )$ and $\delta$ . The second phenomenon is that the slope of $s ( \cdot )$ decreases as $\delta$ increases, showing a trade-off between $s ( \cdot )$ and $\delta$ . Although this trade-off comes naturally from the definition of learnability, it has a deep meaning. As is shown in Section 4, $\operatorname { e r r } ( f )$ is bounded by $O ( s ( \varepsilon ) )$ where $\varepsilon$ is the variation of the model. To make the bound tighter, a natural idea is to choose a flatter $s ( \cdot )$ . However, a flatter $s ( \cdot )$ corresponds to a larger $\delta$ . Typically, learning a model to meet this higher informativeness requirement is more difficult, and it is possible that the algorithm achieves this by capturing more domain-specific features, which will therefore increase the variation of the model, $\varepsilon$ . As a result, we are not sure whether $s ( \varepsilon )$ will increase or decrease. We believe this is also the essence of model selection: i.e., to trade-off between the variation and informativeness of a model, which is done in Formula 11.
+
+# 7 More Related Works
+
+Domain generalization [12, 39], or OOD generalization, has drawn much attention recently [21, 30]. The goal is to learn a model from several training domains and expect good performance on unseen test domains. [60, 64] offer a comprehensive survey. A popular solution is to extract domain-invariant feature representation. [45] and [49] proved that when the model is linear, the invariance under training domains can help discover invariant features on test domains. [5] introduces the invariant prediction into neural networks and proposes a practical objective function. After that, a lot of works arise from the view of causal discovery, distributional robustness and conditional independence [1, 7, 16, 15, 26, 32, 33, 43, 51, 61]. On the other hand, some works point out the weakness of existing methods from the theoretical and experimental perspectives [2, 21, 29, 41, 50].
+
+The OOD generalization requires restrictions on how the target domains may differ. A straightforward approach is to define a set of test domains around the training domain using some distribution distance measure [6, 13, 19, 25, 51, 53, 54, 61]. Another feasible route is the causal framework which is robust to the test distributions caused by interventions[44, 46] on variables, e.g., [5, 24, 36, 37, 40, 47, 49, 52]. The principle of these methods is that a causal model is invariant and can achieve the minimal worstcase risk [4, 22, 44, 49]. Since the test distribution is unknown, additional assumptions are required for generalization analysis. [12, 18, 39] assume that the domains are generated from a hyper-distribution and measures the average risk estimation error bound. [3] derives a risk bound for any linear combination of training domains. For more related results in domain adaptation, a closed field where the test domains can be seen but are unlabeled, please see [9, 10, 28].
+
+# 8 Conclusion
+
+In this paper, we take the first step towards a rigorous theoretical framework of OOD generalization. We propose a mathematical formulation to characterize the learnability of OOD generalization problem. Based on our framework, we prove generalization bounds and give guarantees for OOD generalization error. Inspired by our bound, we design a model selection criterion to check the model’s variation and validation accuracy simultaneously. Experiments show that our metric has a significant advantage over the traditional selection method.
+
+# Acknowledgments and Disclosure of Funding
+
+Authors are thankful to the anonymous reviewers for their helpful and constructive feedback.
+
+# References
+
+[1] Kartik Ahuja, Karthikeyan Shanmugam, Kush Varshney, and Amit Dhurandhar. Invariant risk minimization games. arXiv preprint arXiv:2002.04692, 2020.   
+[2] Kartik Ahuja, Jun Wang, Amit Dhurandhar, Karthikeyan Shanmugam, and Kush R Varshney. Empirical or invariant risk minimization? a sample complexity perspective. arXiv preprint arXiv:2010.16412, 2020.   
+[3] Isabela Albuquerque, João Monteiro, Tiago H Falk, and Ioannis Mitliagkas. Adversarial target-invariant representation learning for domain generalization. arXiv preprint arXiv:1911.00804, 2019.   
+[4] John Aldrich. Autonomy. Oxford Economic Papers, 41(1):15–34, 1989.   
+[5] Martin Arjovsky, Léon Bottou, Ishaan Gulrajani, and David Lopez-Paz. Invariant risk minimization. arXiv preprint arXiv:1907.02893, 2019.   
+[6] J Andrew Bagnell. Robust supervised learning. In Proceedings of the national conference on artificial intelligence, volume 20, page 714. Menlo Park, CA; Cambridge, MA; London; AAAI Press; MIT Press; 1999, 2005.   
+[7] Haoyue Bai, Rui Sun, Lanqing Hong, Fengwei Zhou, Nanyang Ye, Han-Jia Ye, S-H Gary Chan, and Zhenguo Li. Decaug: Out-of-distribution generalization via decomposed feature representation and semantic augmentation. arXiv preprint arXiv:2012.09382, 2020.   
+[8] Sara Beery, Grant Van Horn, and Pietro Perona. Recognition in terra incognita. In Proceedings of the European Conference on Computer Vision (ECCV), September 2018.   
+[9] Shai Ben-David, John Blitzer, Koby Crammer, Fernando Pereira, et al. Analysis of representations for domain adaptation. Advances in neural information processing systems, 19:137, 2007.   
+[10] Shai Ben-David, John Blitzer, Koby Crammer, Alex Kulesza, Fernando Pereira, and Jennifer Wortman Vaughan. A theory of learning from different domains. Machine learning, 79(1):151–175, 2010.   
+[11] Yoshua Bengio, Tristan Deleu, Nasim Rahaman, Nan Rosemary Ke, Sebastien Lachapelle, Olexa Bilaniuk, Anirudh Goyal, and Christopher Pal. A meta-transfer objective for learning to disentangle causal mechanisms. In International Conference on Learning Representations, 2019.   
+[12] Gilles Blanchard, Gyemin Lee, and Clayton Scott. Generalizing from several related classification tasks to a new unlabeled sample. Advances in neural information processing systems, 24:2178–2186, 2011.   
+[13] Jose Blanchet, Yang Kang, Karthyek Murthy, and Fan Zhang. Data-driven optimal transport cost selection for distributionally robust optimization. In 2019 Winter Simulation Conference (WSC), pages 3740–3751. IEEE, 2019.   
+[14] Laurent Cavalier. Efficient estimation of a density in a problem of tomography. Annals of Statistics, pages 630–647, 2000.   
+[15] Shiyu Chang, Yang Zhang, Mo Yu, and Tommi Jaakkola. Invariant rationalization. In International Conference on Machine Learning, pages 1448–1458. PMLR, 2020.   
+[16] Elliot Creager, Joern-Henrik Jacobsen, and Richard Zemel. Exchanging lessons between algorithmic fairness and domain generalization, 2021. URL https://openreview.net/forum?id=DC1Im3MkGG.   
+[17] Alex J DeGrave, Joseph D Janizek, and Su-In Lee. Ai for radiographic covid-19 detection selects shortcuts over signal. medRxiv, 2020.   
+[18] Aniket Anand Deshmukh, Yunwen Lei, Srinagesh Sharma, Urun Dogan, James W Cutler, and Clayton Scott. A generalization error bound for multi-class domain generalization. arXiv preprint arXiv:1905.10392, 2019.   
+[19] Peyman Mohajerin Esfahani and Daniel Kuhn. Data-driven distributionally robust optimization using the wasserstein metric: Performance guarantees and tractable reformulations. Mathematical Programming, 171(1-2):115–166, 2018.   
+[20] Yaroslav Ganin, Evgeniya Ustinova, Hana Ajakan, Pascal Germain, Hugo Larochelle, François Laviolette, Mario Marchand, and Victor Lempitsky. Domain-adversarial training of neural networks. The journal of machine learning research, 17(1):2096–2030, 2016.   
+[21] Ishaan Gulrajani and David Lopez-Paz. In search of lost domain generalization. arXiv preprint arXiv:2007.01434, 2020.   
+[22] Trygve Haavelmo. The probability approach in econometrics. Econometrica: Journal of the Econometric Society, pages iii–115, 1944.   
+[23] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.   
+[24] Christina Heinze-Deml and Nicolai Meinshausen. Conditional variance penalties and domain shift robustness. Machine Learning, 110(2):303–348, 2021.   
+[25] Zhaolin Hu and L Jeff Hong. Kullback-leibler divergence constrained distributionally robust optimization. Available at Optimization Online, 2013.   
+[26] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Domain extrapolation via regret minimization. arXiv preprint arXiv:2006.03908, 2020.   
+[27] Wengong Jin, Regina Barzilay, and Tommi S. Jaakkola. Enforcing predictive invariance across structured biomedical domains, 2021. URL https://openreview.net/forum?id $=$ JywMsiz_NtO.   
+[28] Fredrik D Johansson, David Sontag, and Rajesh Ranganath. Support and invertibility in domain-invariant representations. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 527–536. PMLR, 2019.   
+[29] Pritish Kamath, Akilesh Tangella, Danica J Sutherland, and Nathan Srebro. Does invariant risk minimization capture invariance? arXiv preprint arXiv:2101.01134, 2021.   
+[30] Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Balsubramani, Weihua Hu, Michihiro Yasunaga, Richard Lanas Phillips, Sara Beery, et al. Wilds: A benchmark of in-the-wild distribution shifts. arXiv preprint arXiv:2012.07421, 2020.   
+[31] Aleksandr Petrovich Korostelev and Alexandre B Tsybakov. Minimax theory of image reconstruction, volume 82. Springer Science & Business Media, 2012.   
+[32] Masanori Koyama and Shoichiro Yamaguchi. Out-of-distribution generalization with maximal invariant predictor. arXiv preprint arXiv:2008.01883, 2020.   
+[33] David Krueger, Ethan Caballero, Joern-Henrik Jacobsen, Amy Zhang, Jonathan Binas, Remi Le Priol, and Aaron Courville. Out-of-distribution generalization via risk extrapolation (rex). arXiv preprint arXiv:2003.00688, 2020.   
+[34] Da Li, Yongxin Yang, Yi-Zhe Song, and Timothy M Hospedales. Deeper, broader and artier domain generalization. In Proceedings of the IEEE international conference on computer vision, pages 5542–5550, 2017.   
+[35] Haoliang Li, Sinno Jialin Pan, Shiqi Wang, and Alex C Kot. Domain generalization with adversarial feature learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5400–5409, 2018.   
+[36] Sara Magliacane, Thijs van Ommen, Tom Claassen, Stephan Bongers, Philip Versteeg, and Joris M Mooij. Domain adaptation by using causal inference to predict invariant conditional distributions. arXiv preprint arXiv:1707.06422, 2017.   
+[37] Nicolai Meinshausen. Causality from a distributional robustness point of view. In 2018 IEEE Data Science Workshop (DSW), pages 6–10. IEEE, 2018.   
+[38] Jose G Moreno-Torres, Troy Raeder, Rocío Alaiz-Rodríguez, Nitesh V Chawla, and Francisco Herrera. A unifying view on dataset shift in classification. Pattern recognition, 45(1):521–530, 2012.   
+[39] Krikamol Muandet, David Balduzzi, and Bernhard Schölkopf. Domain generalization via invariant feature representation. In International Conference on Machine Learning, pages 10–18, 2013.   
+[40] Jens Müller, Robert Schmier, Lynton Ardizzone, Carsten Rother, and Ullrich Köthe. Learning robust models using the principle of independent causal mechanisms. arXiv preprint arXiv:2010.07167, 2020.   
+[41] Vaishnavh Nagarajan, Anders Andreassen, and Behnam Neyshabur. Understanding the failure modes of out-of-distribution generalization. arXiv preprint arXiv:2010.15775, 2020.   
+[42] Frank Natterer. The mathematics of computerized tomography. SIAM, 2001.   
+[43] Giambattista Parascandolo, Alexander Neitz, Antonio Orvieto, Luigi Gresele, and Bernhard Schölkopf. Learning explanations that are hard to vary. arXiv preprint arXiv:2009.00329, 2020.   
+[44] Judea Pearl. Causality. Cambridge university press, 2009.   
+[45] Jonas Peters, Peter Bühlmann, and Nicolai Meinshausen. Causal inference by using invariant prediction: identification and confidence intervals. Journal of the Royal Statistical Society. Series B (Statistical Methodology), pages 947–1012, 2016.   
+[46] Jonas Peters, Dominik Janzing, and Bernhard Schölkopf. Elements of causal inference: foundations and learning algorithms. The MIT Press, 2017.   
+[47] Niklas Pfister, Evan G Williams, Jonas Peters, Ruedi Aebersold, and Peter Bühlmann. Stabilizing variable selection and regression. arXiv preprint arXiv:1911.01850, 2019.   
+[48] Benjamin Recht, Rebecca Roelofs, Ludwig Schmidt, and Vaishaal Shankar. Do imagenet classifiers generalize to imagenet? In International Conference on Machine Learning, pages 5389–5400. PMLR, 2019.   
+[49] Mateo Rojas-Carulla, Bernhard Schölkopf, Richard Turner, and Jonas Peters. Invariant models for causal transfer learning. The Journal of Machine Learning Research, 19(1):1309–1342, 2018.   
+[50] Elan Rosenfeld, Pradeep Ravikumar, and Andrej Risteski. The risks of invariant risk minimization. arXiv preprint arXiv:2010.05761, 2020.   
+[51] Shiori Sagawa, Pang Wei Koh, Tatsunori B Hashimoto, and Percy Liang. Distributionally robust neural networks. In International Conference on Learning Representations, 2019.   
+[52] Bernhard Schölkopf, Dominik Janzing, Jonas Peters, Eleni Sgouritsa, Kun Zhang, and Joris Mooij. On causal and anticausal learning. arXiv preprint arXiv:1206.6471, 2012.   
+[53] Soroosh Shafieezadeh Abadeh, Peyman M Mohajerin Esfahani, and Daniel Kuhn. Distributionally robust logistic regression. Advances in Neural Information Processing Systems, 28:1576–1584, 2015.   
+[54] Aman Sinha, Hongseok Namkoong, and John Duchi. Certifying some distributional robustness with principled adversarial training. In International Conference on Learning Representations, 2018.   
+[55] Baochen Sun and Kate Saenko. Deep coral: Correlation alignment for deep domain adaptation. In European conference on computer vision, pages 443–450. Springer, 2016.   
+[56] Rohan Taori, Achal Dave, Vaishaal Shankar, Nicholas Carlini, Benjamin Recht, and Ludwig Schmidt. Measuring robustness to natural distribution shifts in image classification. Advances in Neural Information Processing Systems, 33, 2020.   
+[57] Antonio Torralba and Alexei A Efros. Unbiased look at dataset bias. In CVPR 2011, pages 1521–1528. IEEE, 2011.   
+[58] Vladimir Vapnik. Principles of risk minimization for learning theory. In Advances in neural information processing systems, pages 831–838, 1992.   
+[59] Hemanth Venkateswara, Jose Eusebio, Shayok Chakraborty, and Sethuraman Panchanathan. Deep hashing network for unsupervised domain adaptation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 5018–5027, 2017.   
+[60] Jindong Wang, Cuiling Lan, Chang Liu, Yidong Ouyang, Wenjun Zeng, and Tao Qin. Generalizing to unseen domains: A survey on domain generalization. arXiv preprint arXiv:2103.03097, 2021.   
+[61] Chuanlong Xie, Fei Chen, Yue Liu, and Zhenguo Li. Risk variance penalization. arXiv preprint arXiv:2006.07544, 2020.   
+[62] Shen Yan, Huan Song, Nanxiang Li, Lincan Zou, and Liu Ren. Improve unsupervised domain adaptation with mixup training. arXiv preprint arXiv:2001.00677, 2020.   
+[63] Haotian Ye, Chuanlong Xie, Yue Liu, and Zhenguo Li. Out-of-distribution generalization analysis via influence function. arXiv preprint arXiv:2101.08521, 2021.   
+[64] Kaiyang Zhou, Ziwei Liu, Yu Qiao, Tao Xiang, and Chen Change Loy. Domain generalization: A survey. arXiv preprint arXiv:2103.02503, 2021.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 5.   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (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] In the appendix.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [N/A]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] We use [21] and we cite it in Section 6.   
+(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? [Yes]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/Bkx0RjA9tX/Bkx0RjA9tX.md

@@ -0,0 +1,342 @@
+# GENERATIVE QUESTION ANSWERING: LEARNING TO ANSWER THE WHOLE QUESTION
+
+Mike Lewis & Angela Fan Facebook AI Research {mikelewis,angelafan}@fb.com
+
+# ABSTRACT
+
+Discriminative question answering models can overfit to superficial biases in datasets, because their loss function saturates when any clue makes the answer likely. We introduce generative models of the joint distribution of questions and answers, which are trained to explain the whole question, not just to answer it. Our question answering (QA) model is implemented by learning a prior over answers, and a conditional language model to generate the question given the answer— allowing scalable and interpretable many-hop reasoning as the question is generated word-by-word. Our model achieves competitive performance with comparable discriminative models on the SQUAD and CLEVR benchmarks, indicating that it is a more general architecture for language understanding and reasoning than previous work. The model greatly improves generalisation both from biased training data and to adversarial testing data, achieving state-of-the-art results on ADVERSARIALSQUAD.
+
+# 1 INTRODUCTION
+
+Question answering tasks are widely used for training and testing machine comprehension and reasoning (Rajpurkar et al., 2016; Joshi et al., 2017). However, high performance has been achieved with only superficial understanding, as models exploit simple correlations in the data (Weissenborn et al., 2017; Zhou et al., 2015). For example, in Visual QA (Agrawal et al., 2017), the answer to What colour is the grass? can be memorised as green without considering the image (Figure 1).
+
+We argue that this over-fitting to biases is partly caused by discriminative loss functions, which saturate when simple correlations allow the question to be answered confidently, leaving no incentive for further learning on the example.
+
+We propose generative QA models, using Bayes’ rule to reparameterise the distribution of answers given questions in terms of the distribution of questions given answers. We learn a prior over answers and a conditional language model for generating the question—reducing question answering to sequence-to-sequence learning (Sutskever et al., 2014), and allowing many-hop reasoning as the model explains the whole question word-by-word.
+
+Generative loss functions train the model to explain all question words, even if the answer is obvious. For example, a model cannot assign high probability to generating the question What colour is the grass? without learning a dependency between the image and the word grass. We show that this method allows much improved generalisation from biased training data and to adversarial test data, compared to state-of-the-art discriminative models.
+
+Word-by-word generative modelling of questions also supports chains of reasoning, as each subpart of the question is explained in turn. Existing methods use a pre-specified number of reasoning steps (Sukhbaatar et al., 2015; Hudson & Manning, 2018), which may be too many steps on easy cases, and too few on long and complex questions. We instead perform an interpretable reasoning step for each question word, and achieve $9 7 . 7 \%$ accuracy on the CLEVR benchmark (Johnson et al., 2017).
+
+Our approach opens a promising new direction for question answering, with strong results in language understanding, reasoning and generalisation.
+
+![](images/4ea3ae44df91abbf802dd70ffd949fe57baa29e2dc6df16e8c5ad6e7813f40b1.jpg)
+
+Does the green rubber object have the same shape as the gray thing that is on the right side of the big purple object?
+
+Is the purple thing the same shape as the large gray rubber thing?
+
+(a) Two CLEVR questions. Both can be answered no using only subsets of the available information. A generative model must learn to perform additional reasoning to assign high likelihood to the complete question-answer pair. Word-by-word question generation allows a reasoning step to explain each word.
+
+Whilst filming in Mexico City, speculation in the media claimed that the script had been altered to accommodate the demands of Mexican authorities reportedly influencing details of the scene and characters, casting choices, and modifying the script in order to portray the country in a “positive light” in order to secure tax concessions and financial support worth up to $\$ 20$ million for the film. This was denied by producer Michael G. Wilson.
+
+Which Bond producer would not confirm that the film had been changed to accommodate Mexican authorities?
+
+(b) A SQUAD question. A discriminative model can identify the only producer, and ignore the rest of the question. To generate the question and answer, our model needs coreference, negation and paraphrasing. These reasoning skills can improve generalisation on test examples with multiple plausible answers.
+
+Figure 1: Examples of questions that can be answered using only some question words (underlined).
+
+# 2 MODEL
+
+# 2.1 OVERVIEW
+
+We assume a dataset of examples with a question $q = q _ { 0 . . T }$ , answer $a$ , and context $c$ (in our experiments, $c$ is a document or image, but alternatives such as knowledge graphs could be used).
+
+We train models to minimize the negative log likelihood of the joint distribution of questions and answers given the context, $- \log p ( q , a | c )$ , which we decompose using the chain rule as:
+
+$$
+\mathcal { L } = - \log p ( a | c ) - \sum _ { t } \log p ( q _ { t } | a , c , q _ { 0 . . t - 1 } )
+$$
+
+First $c$ is encoded, using a recurrent model for text $( \ S 2 . 2 )$ and a using a convolutional model for images (§2.3).
+
+Then, a prior over answers $p ( a | c )$ is evaluated by scoring all possible answers (2.4).
+
+The likelihood of the question $p ( q | a , c )$ is modelled using a conditional language model (§2.5).
+
+At test time, the answer maximizing $p ( q , a | c )$ is returned1 (§2.7).
+
+Hyperparameters and training details are fully described in Appendix A.
+
+# 2.2 DOCUMENT ENCODER
+
+Answer-independent Context Representation We use contextualised word representations, similar to ELMo (Peters et al., 2018). We use character-based word embeddings (Kim et al., 2016) and train a 2-layer LSTM language model in the forward and reverse directions, using the WikiText-103 corpus (Merity et al., 2016) for domain-specificity2. These parameters are frozen, and not finetuned. Contextualised word representations are computed as a fully connected layer applied to the concatenation of the word embedding and the hidden states of each layer of the language model. We sum this representation with a trainable vector of size $d$ if the word occurs in the article title, giving the encoder information about the article topic. We follow this with bidirectional LSTMs of size $d / 2$ , concatenating the output in each direction and adding residual connections after each layer.
+
+What we now call gravity was not identified as a universal force until the work of Isaac Newton. [...] Galileo was instrumental in describing the characteristics of falling objects [...] this acceleration due to gravity towards the surface of the Earth is usually designated as and has a magnitude of about 9.81 meters per second squared [...], and points toward the center of the Earth. [...] Distractor: Object falls about 5 times faster on Mars.
+
+![](images/11e6c9fa19f967ab01fb9398ccc26793a802ffce483743e59f947b1cb08b413a.jpg)  
+Figure 2: Probabilities of generating question words given different answers for a standard and an adversarial SQUAD question, allowing us to interpret which questions words are explained by the answer. In the standard setting, the model places greater probability on the question words that appear near Isaac Newton, such as force compared to Galileo. In the adversarial setting, the question word Earth distinguishes the true answer from the distractor.
+
+Answer Encoder We assume answers $a$ are a span $i . . j$ of the document. We represent the answer as a weighted sum of words within the span. For each word representation $\begin{array} { r } { \sum _ { k = i \ldots j } \sigma ( w \cdot \tilde { c } _ { k } ) \tilde { c } _ { k } } \end{array}$ , where $w \in R ^ { d }$ is a trainable vector, and $\tilde { c } _ { k }$ is the kth word in the answer-independent document representation. In contrast to previously proposed span representations (Lee et al., 2016; He et al., 2018), this approach allows the model to select arbitrarily many head words from the span.
+
+Answer-dependent Context Representation Generative training makes it feasible to model more complex interactions between the answer and context than discriminative training, because only the correct answer is used. On SQUAD, we compute an answer-dependent document representation.
+
+Here, we take the output of the answer-independent representation of each context word, and concatenate it with 32-dimensional embeddings of: a binary feature for whether the word is contained in the answer, its position relative to the answer start, and its position relative to the answer end. We also concatenate the element-wise product of the word representation and the answer encoding. We feed the result into 3 further layers of residual bidirectional LSTMs of size $d / 2$ .
+
+# 2.3 IMAGE ENCODER
+
+We use a simple image encoder, leaving reasoning to the question decoder.
+
+Following Johnson et al. (2017), we take pre-trained features from the conv4 layer ResNet-101 model (He et al., 2016), giving 1024-dimensional features for a $1 4 \mathrm { x } 1 4$ image grid. We apply dropout, and project these representations to size $d$ using a 1x1 convolution, followed by batch normalisation (Ioffe & Szegedy, 2015) and a ReLU activation (Nair & Hinton, 2010). We then use 2 blocks of $3 { \tt X } 3$ convolutions, batch normalisation and ReLUs, and concatenate the final representation with a 32-dimensional positional encoding.
+
+# 2.4 ANSWER PRIOR
+
+We found modelling $p ( a | c )$ , the distribution over answers given the context, to be straightforward.
+
+On SQUAD, we concatenate the start and end representations of the answer-independent context representation, combine them with a single hidden layer of size $2 d$ and ReLU activation, and project this representation down to a score $s ^ { \mathrm { e n d p o i n t s } } ( a , c )$ . We also add an additional score based only on the length of the answer $s ^ { \mathrm { l e n g t h } } ( a )$ . Finally, we calculate: $\begin{array} { r } { p ( a | c ) = \frac { \exp { ( s ^ { \mathrm { e n d p o i n t s } } ( a , c ) + s ^ { \mathrm { l e n g t h } } ( a ) ) } } { \sum _ { a ^ { \prime } } \exp { ( s ^ { \mathrm { e n d p o i n t s } } ( a ^ { \prime } , c ) + s ^ { \mathrm { l e n g t h } } ( a ^ { \prime } ) ) } } } \end{array}$
+
+On CLEVR, we simply apply a fully connected layer of size $2 d$ and ReLU activation to the image representation, followed by a projection to the space of all possible answers and a softmax.
+
+![](images/54abe8f1cd06caa9b40dbab56e9c8335e02379b89c46c2e60fc4a281b7e382e3.jpg)  
+Figure 3: Architecture of GQA decoder. Multiple inputs to a layer indicates concatenation. Blocks after the first are connected with an additional residual connection, and LSTM cells also receive their state at time $t - 1$ as an input.
+
+# 2.5 QUESTION DECODER
+
+We generate question words left-to-right with teacher forcing. We first embed words independently of the context (§2.5.1), then use a multi-layer RNN with attention to model interactions between the question and context $( \ S 2 . 5 . 2 )$ , and finally compute the likelihood of the next word (§2.5.3).
+
+# 2.5.1 INPUT WORD EMBEDDINGS
+
+To represent SQUAD question words independently of the answer and document, we use a pretrained left-to-right language model (which can be viewed as a uni-directional version of ELMo), followed by a trainable LSTM layer of size $d$ . On CLEVR, we simply train embeddings of size $d$ .
+
+# 2.5.2 DECODER BLOCKS
+
+Decoder blocks are composed of a question self-attention layer (Vaswani et al., 2017) and a questionto-context attention mechanism, which are combined and fed into an LSTM (Figure 3). The context attention query is computed using both the previous layer state and the self-attention value. Blocks after the first are connected with residual connections.
+
+Our attention mechanisms are implemented as in Vaswani et al., except that we use a single-headed attention, and a bias term $b _ { j }$ is added to the query-key score for context position $j$ . This bias term (calculated as a dot product of a shared trainable vector and context encoding $c _ { j }$ ) allows the model to easily filter out parts of the context which are irrelevant to the question.
+
+A final block again uses self-attention and question-to-document attention, which are then combined with a Gated Linear Unit layer (Dauphin et al., 2017) to output a vector of size $d$ . The GLU layer uses a gating mechanism to select the relevant information for predicting the subsequent word.
+
+# 2.5.3 OUTPUT WORD PROBABILITIES
+
+Rare words are more challenging for generative than discriminative models, because it is easier to guess the meaning of a rare word from morphological clues than to generate it. SQUAD contains many rare words, because of the specialised vocabulary in Wikipedia. We improve modelling of rare words using a combination of an approximate character-based softmax and copy mechanism.
+
+Word Softmax The simplest approach is to learn an embedding per word, replacing infrequent words with an unknown token. This approach cannot discriminate between different rare words. We use this method on CLEVR, which has a small vocabulary.
+
+![](images/57145f9925bdfa9d12c796b1ebbe1a25908c21eec1e131efb7b0370bb907722f.jpg)  
+Figure 4: Final layer attention maps and word probabilities during question generation on a CLEVR validation question, when predicting the highlighted word. (1) The model considers all the rubber objects for predicting the next word. (2) Objects to the left of a rubber object are considered. (3) It describes the brown cylinder. (4, 5) Word distributions show the model understands the next words, but interestingly its attention focuses on the set of two objects meeting the constraints. In all cases, the word probability distributions are heavily skewed towards semantically valid choices.
+
+Character Softmax While there is an infinite space of possible output words, we approximate it by only normalising over the union of a list of frequent words, and any additional word that appears in any question or any document in the batch. We build a character-based representation for each candidate word using the pre-trained character CNN from $\ S 2 . 2$ , and add a trainable linear projection to size $d$ . We combine character-based and word-based representations by summation.
+
+Pointer Mechanism We use a pointer mechanism (Vinyals et al., 2015) to improve the likelihood of the specialised vocabulary present in SQUAD, by copying article words. From the final hidden state $h _ { t }$ , the model first chooses whether to copy using a simple classifier $p ^ { \mathrm { c o p y } } ( h ) = \sigma ( w ^ { \mathrm { c o p y } } \cdot h ) .$ , where $w ^ { \mathrm { c o p y } }$ is a trainable vector of size $d$ . Then, the model interpolates between generating a word with softmax $p ^ { \mathrm { g e n } } ( h )$ and copying context word $c _ { i }$ using the question-to-context attention probability from the final layer $\dot { \alpha } _ { t } ^ { i }$ : $p ( q _ { t } \vert \mathbf { \bar { q } } _ { 0 : t - 1 } , c , a ) = p ^ { \mathrm { c o p y } } ( h _ { t } ) \sum _ { i } \alpha _ { t } ^ { i } \hat { \mathbb { 1 } } _ { c _ { i } = q _ { t } } + ( 1 - p ^ { \mathrm { c o p y } } ( h _ { t } ) ) p ^ { \mathrm { g e n } } \mathbf { \bar { ( } } q _ { t } | h _ { t } )$
+
+# 2.6 FINE TUNING
+
+Generative training using teacher forcing means that the model is not exposed to negative combinations of questions and answers at training time, so performance on these combinations may be weak when used for inference. For example, the model can overfit as a language model on questions, and ignore dependencies to the answer. Results can be improved by fine-tuning the model to make the question more likely under the gold answer than other plausible answers. Here, we minimize $- \log \frac { p ( q | a , c ) p ( a | \bar { c } ) } { \sum _ { a ^ { \prime } \in A } p ( q | a ^ { \prime } , c ) p ( a ^ { \prime } | c ) }$ , where $A$ is the most likely 100 answer candidates from $p ( a | c )$ . The model performs poorly when trained using only this loss function, suggesting that generative pretraining allows the model to establish complex dependencies between the input and output, which can then be calibrated discriminatively (Table 2).
+
+# 2.7 INFERENCE
+
+We return the answer $a ^ { * }$ maximizing $a ^ { * } = \mathrm { a r g m a x } _ { a } p ( q | a , c ) p ( a | c )$ , which requires evaluating the likelihood of the given question under each possible answer.
+
+To efficiently handle the large number of possible answers in SQUAD, we use beam search. We evaluate $p ( a | c )$ for all possible answer spans up to length 30, take the top 250 candidates, and only evaluate $p ( q | a , c )$ for each of these. A correct answer is contained in the beam for over $9 8 . 5 \%$ o f validation questions, suggesting that approximate inference is not a major cause of errors.
+
+Table 1: Exact Match (EM) and F1 on SQUAD, comparing to the best published single models at the time of submission (September 2018).   
+
+<table><tr><td rowspan="2">Single Model</td><td colspan="2">Development</td><td colspan="2">Test</td></tr><tr><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>RaSOR (Lee et al., 2016)</td><td>66.4</td><td>74.9</td><td>67.4</td><td>75.5</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>67.7</td><td>77.3</td><td>68.0</td><td>77.3</td></tr><tr><td>DrQA (Chen et al., 2017)</td><td>69.5</td><td>78.8</td><td>70.7</td><td>79.3</td></tr><tr><td>R-Net (Wang et al., 2017)</td><td>71.1</td><td>79.5</td><td>72.3</td><td>80.7</td></tr><tr><td>Weaver (Raison et al., 2018)</td><td>74.1</td><td>82.4</td><td>74.4</td><td>82.8</td></tr><tr><td>DCN+ (Xiong et al., 2017)</td><td>74.5</td><td>83.1</td><td>75.1</td><td>83.1</td></tr><tr><td>QANet + data augmentation x3 (Yu et al., 2018)</td><td>75.1</td><td>83.8</td><td>76.2</td><td>84.6</td></tr><tr><td>BiDAF + Self Attention + ELMo (Peters et al., 2018)</td><td>=</td><td>85.6</td><td>78.6</td><td>85.8</td></tr><tr><td>Reinforced Mnemonic Reader (Hu et al., 2018)</td><td>78.9</td><td>86.3</td><td>79.5</td><td>86.6</td></tr><tr><td>GQA</td><td>76.8</td><td>83.7</td><td>77.1</td><td>83.9</td></tr></table>
+
+Table 2: Development results on SQUAD for model ablations.   
+
+<table><tr><td>Single Model</td><td>Exact Match</td><td>F1</td></tr><tr><td>GQA</td><td>76.8</td><td>83.7</td></tr><tr><td>GQA (no fine-tuning)</td><td>72.3</td><td>80.1</td></tr><tr><td>GQA (no generative training)</td><td>64.5</td><td>72.2</td></tr><tr><td>GQA (no character-based softmax)</td><td>74.3</td><td>81.4</td></tr><tr><td>GQA (no pointer mechanism)</td><td>71.9</td><td>79.7</td></tr><tr><td>GQA (no answer-dependent context representation)</td><td>72.2</td><td>79.7</td></tr><tr><td>GQA (answer prior only)</td><td>13.4</td><td>16.1</td></tr></table>
+
+# 3 EXPERIMENTS
+
+# 3.1 LARGE-SCALE READING COMPREHENSION
+
+We evaluate our model (GQA) on the SQUAD dataset to test its robustness to diverse syntactic and lexical inferences. Results are shown in Table 1, and are competitive with comparable discriminative models, despite several years of incremental progress on discriminative architectures for this task. These results show the potential of generative models for such tasks.
+
+Higher results have been reported using techniques such as ensembles, data augmentation, reinforcement learning with the end-task metric a reward, and breakthroughs in unsupervised pre-training.
+
+Table 2 shows several ablations. It demonstrates the importance of the character-based softmax and pointer mechanism for modelling rare words, the need to model interactions between the answer and context, and a large improvement from fine-tuning the model with negative question-answer pairs.
+
+The ablations also highlight that while fine-tuning the model with a discriminative objective substantially improves the results, performance is weak when trained discriminatively from scratch. This result suggests that generative training is learning additional relationships, but can benefit from being calibrated and exposed to negative question-answer pairs during fine tuning.
+
+Table 3 shows an ablation study for the number of answer candidates considered in the beam of possible answers at inference time. Considering a larger number of answer candidates improves results, but increases the computational cost as the likelihood of the question must be calculated for each candidate.
+
+# 3.2 MULTIHOP REASONING
+
+We evaluate the ability of our model to perform multihop reasoning on the CLEVR dataset, which consists of images paired with automatically generated questions involving that test visual reasoning.
+
+Table 4 shows that GQA achieves an accuracy of $9 7 . 7 \%$ , compared to $7 6 . 6 \%$ for a standard visual QA model, demonstrating that our generative architecture can perform complex reasoning. Integrat
+
+Table 3: Development results on SQUAD, varying the beam size during inference.   
+
+<table><tr><td>#Answer Candidates</td><td>Exact Match</td><td>F1</td></tr><tr><td>250</td><td>76.8</td><td>83.7</td></tr><tr><td>200</td><td>76.6</td><td>83.4</td></tr><tr><td>100</td><td>76.2</td><td>83.1</td></tr><tr><td>50</td><td>74.6</td><td>81.4</td></tr><tr><td>10</td><td>55.7</td><td>61.4</td></tr></table>
+
+Table 4: Test results on CLEVR, demonstrating high accuracy at complex reasoning. GQA is the first approach to achieve high performance on both CLEVR and broad coverage QA tasks.   
+
+<table><tr><td>Single Model</td><td>Overall</td><td>Count</td><td>Exist</td><td>Compare Numbers</td><td>Query Attribute</td><td>Compare Attribute</td></tr><tr><td>Human</td><td>92.6</td><td>86.7</td><td>96.6</td><td>86.5</td><td>95.0</td><td>96.0</td></tr><tr><td>CNN+LSTM</td><td>52.3</td><td>43.7</td><td>65.2</td><td>67.1</td><td>49.3</td><td>53.0</td></tr><tr><td>CNN+LSTM+SA</td><td>76.6</td><td>64.4</td><td>82.7</td><td>77.4</td><td>82.6</td><td>75.4</td></tr><tr><td>CNN+LSTM+RN</td><td>95.5</td><td>90.1</td><td>97.8</td><td>93.6</td><td>97.9</td><td>97.1</td></tr><tr><td>CNN+GRU+FiLM</td><td>97.6</td><td>94.3</td><td>99.3</td><td>93.4</td><td>99.3</td><td>99.3</td></tr><tr><td>MAC</td><td>98.9</td><td>97.1</td><td>99.5</td><td>99.1</td><td>99.5</td><td>99.5</td></tr><tr><td>GQA</td><td>97.7</td><td>94.9</td><td>98.3</td><td>97.0</td><td>99.2</td><td>99.2</td></tr></table>
+
+ing MAC cells (Hudson & Manning, 2018) into our decoder or FiLM layers (Perez et al., 2018) into our encoder would be straightforward, and may improve results, but we avoid these techniques to emphasise that generative decoding alone allows multihop reasoning.
+
+Figure 4 shows an example of how the model decomposes the reasoning over the question. It initially pays attention to all shapes, but updates its attention mask after new words are read.
+
+# 3.3 LEARNING FROM BIASED DATA
+
+Many popular QA datasets are well known to contain biases that models can exploit. Examples include when questions paired with paragraphs that contain a single date. Models can exploit biases by learning simple heuristics such as selecting answers based on the expected answer type (Weissenborn et al., 2017; Rondeau & Hazen, 2018). Recent work has attempted to remove some biases (Goyal et al., 2017; Rajpurkar et al., 2018); we instead attempt to make training robust to bias.
+
+We create deliberately biased training subsets of SQUAD based on named entity types: numbers, dates, and people. To construct each training set, we select questions whose answer is one of these types, but that type only appears once in the document (e.g. Figure 1b). The validation set is created from questions whose answers are the named entity type, but there must be multiple occurrences of that type in the document. Each training and validation set contains rougly 1000 questions.
+
+We compare our model to two strong discriminative models, BiDAF (Seo et al., 2016) and QANet3 (Yu et al., 2018). We also report three question agnostic baselines: a random answer of the correct type, the first answer of the correct type, and the GQA answer prior distribtion.
+
+Results are shown in Table 5, and show that discriminatively trained models perform similarly to question-agnostic baselines. In contrast, our generative model learns to generalise meaningfully even from highly biased data, because it is trained to explain the whole question, not simply to answer it—demonstrating that on some QA tasks, there are clear advantages to generative modelling.
+
+# 3.4 ADVERSARIAL EVALUATION
+
+We evaluate on an adversarial version of the SQUAD dataset (Jia & Liang, 2017), which was created by adding a distractor sentence to each paragraph that can almost answer the question.
+
+Table 5: Exact Match (EM) and F1 on biased subsets of SQUAD. All answers in each subset have the indicated named-entity type; training documents have only one answer with this type, but for testing there are multiple plausible answers. Discriminative models perform comparably to questionagnostic baselines, whereas our generative model learns to generalise.   
+
+<table><tr><td rowspan="2">Single Model</td><td colspan="2">Numbers</td><td colspan="2">Dates</td><td colspan="2">People</td></tr><tr><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>Random Selection First Occurrence</td><td>19.37 29.36</td><td>26.18 35.11</td><td>19.37 34.64</td><td>26.18</td><td>19.37</td><td>26.18</td></tr><tr><td>BiDAF</td><td>33.02</td><td>42.14</td><td>35.41</td><td>42.08 43.83</td><td>26.38 30.05</td><td>32.26 37.28</td></tr><tr><td>QANet</td><td>31.99</td><td>40.58</td><td>39.98</td><td>47.82</td><td>30.26</td><td>38.56</td></tr><tr><td>GQA (answer prior only)</td><td>37.15</td><td>45.54</td><td>35.55</td><td>43.85</td><td>32.56</td><td>38.79</td></tr><tr><td>GQA</td><td>58.49</td><td>67.56</td><td>64.71</td><td>72.51</td><td>53.09</td><td>61.93</td></tr></table>
+
+Table 6: F1 scores on ADVERSARIALSQUAD (from September 2018), which demonstrate that our generative QA model is substantially more robust to this adversary than previous work, likely because the additional adversarial context sentence cannot explain all the question words.   
+
+<table><tr><td>Single Model</td><td>ADDSENT</td><td>ADDONESENT</td></tr><tr><td>BiDAF (Seo et al.,2016)</td><td>34.3</td><td>45.7</td></tr><tr><td>RaSOR (Lee et al., 2016)</td><td>39.5</td><td>49.5</td></tr><tr><td>MPCM (Wang et al., 2016)</td><td>40.3</td><td>50.0</td></tr><tr><td>ReasoNet (Shen etal., 2017)</td><td>39.4</td><td>50.3</td></tr><tr><td>Reinforced Mnemonic Reader (Hu et al., 2018)</td><td>46.6</td><td>56.0</td></tr><tr><td>QANet (Yu et al., 2018)</td><td>45.2</td><td>55.7</td></tr><tr><td>GQA</td><td>47.3</td><td>57.8</td></tr></table>
+
+Table 6 shows that GQA outperforms the best previous work by up to $2 . 1 \ \mathrm { F 1 }$ , making it the most robust model to these adversarial attacks. The improvement may be due to the model’s attempt to explain all question words, some of which may be unlikely under the distractor (Figure 2).
+
+# 3.5 LONG CONTEXT QUESTION ANSWERING
+
+Finally, we extend our generative model to answering questions in a more challenging, multiparagraph setting. While we train on single paragraphs, our model can be used to answer questions with multi-paragraph context. During training, our model $p ( q \mid a , c )$ depends only on the content of the paragraph $c$ containing the correct answer $a$ . In contrast, discriminative models need to be trained to discriminate against all negative answers from all paragraphs.
+
+We use the multi-paragraph SQUAD dataset of Raison et al. (2018), where each question is paired with the entire corresponding Wikipedia article. For each question, we calculate $p ( q \mid a ) s ( a , c )$ for the proposed answer span $a$ produced by the model, where $s ( a , c )$ is the logits from the answer prior classifier. The maximum value across all paragraphs of that article is selected as the answer for that question. Table 7 shows that GQA outperforms previous work on this task by $2 . 5 \ : \mathrm { F 1 }$ . Further, discriminative models such as DrQA and Weaver require training in the multi-paragraph setting to perform well, which is expensive and may not scale to longer contexts. However, our generative approach performs well in the multi-paragraph test setting but only requires single paragraph training.
+
+# 4 RELATED WORK
+
+Our model is inspired by the classic noisy channel translation models of Brown et al. (1993), more recently explored by Yu et al. (2016), which were motivated by the ease of incorporating a prior over outputs. Generative models have been widely used in other language classification tasks, such as sequence tagging (Brants, 2000) and parsing (Collins, 1997; Dyer et al., 2016). Generative classification models became less popular because of the difficulty of modelling the input (Sutton & McCallum, 2012), a challenge we embrace as an additional learning signal. Recent work has shown the effectiveness of generative pre-training on unlabelled data (Peters et al., 2018; Radford et al., 2018), we show additional gains from training generatively on labelled data.
+
+Table 7: F1 scores on full document evaluation for SQUAD, which show our generative QA model is capable of selecting the correct paragraph for question answering even when presented with other similar paragraphs. Baselines are from (Raison et al., 2018).   
+
+<table><tr><td>Single Model EM F1</td></tr><tr><td>DrQA* trained on paragraph 59.1 67.0 Weaver trained on paragraph 60.6 69.7</td></tr><tr><td>DrQA* trained on documents 64.7 73.2</td></tr><tr><td>Weaver trained on documents 67.0 75.9 GQA trained on paragraph 71.4 78.4</td></tr></table>
+
+Several studies have explored the relationship between question answering and question generation. Duan et al. (2017) and Tang et al. (2017) train answering and generation models with separate parameters, but add a regularisation term that encourages the models to be consistent. They focus on answer sentence selection, so performance cannot easily be compared with our work. Tang et al. (2018) use question generation to provide an additional loss to improve question answering systems using GAN-like training. Li et al. (2017) apply similar techniques to visual QA. Our work differs in training a single model for the joint distribution of questions and answers, which can be used to calculate conditional distributions for question generation or answering. Sachan & Xing (2018) improve performance by generating new question-answer pairs for training from unlabelled text, which would be a possible extension to our work. Echihabi & Marcu (2003) describe an earlier method for answering questions in terms of the distribution of questions given answers—one conceptual difference is that their approach does not include a prior over answers.
+
+Question generation has also been studied as a task in its own right. Heilman & Smith (2010) use a rule-based system to generate candidate questions, followed by statistical ranking. Du et al. (2017) use a sequence-to-sequence model that encodes paragraph and sentence level information to generate questions. Cardie & Du (2018) propose using a coreference mechanism to incorporate contextual information from multiple sentences. Liu et al. (2017) explore question generation from images, which they refer to as Inverse Visual QA. Yuan et al. (2017) fine-tune a question generation model using reinforcement learning, based on fluency and whether it can be answered. Although we train a question generation model, our focus is on using it to answer questions.
+
+# 5 CONCLUSION
+
+We introduced a generative model for question answering, which leverages the greater amount of information in questions than answers to achieve high performance in both language comprehension and reasoning. The approach demonstrates better robustness to biased training data and adversarial testing data than state-of-the-art discriminative models. There are numerous interesting directions for future work, such as combining information about an entity from multiple sources to generate questions. Given the rapid progress made on discriminative QA models in recent years, we believe there is significant potential for further improvements in generative question answering.
+
+# REFERENCES
+
+Aishwarya Agrawal, Jiasen Lu, Stanislaw Antol, Margaret Mitchell, C. Lawrence Zitnick, Devi Parikh, and Dhruv Batra. Vqa: Visual question answering. Int. J. Comput. Vision, 123(1):4–31, May 2017. ISSN 0920-5691. URL https://doi.org/10.1007/ s11263-016-0966-6.
+
+Thorsten Brants. TnT: a statistical part-of-speech tagger. In Proceedings of the sixth conference on Applied natural language processing, pp. 224–231. Association for Computational Linguistics, 2000.
+
+Peter F. Brown, Stephen Della Pietra, Vincent J. Della Pietra, and Robert L. Mercer. The mathematics of statistical machine translation: Parameter estimation. Computational Linguistics, 19(2): 263–311, 1993.
+
+Claire Cardie and Xinya Du. Harvesting paragraph-level question-answer pairs from wikipedia. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics, ACL 2018, Melbourne, Australia, July 15-20, 2018, Volume 1: Long Papers, pp. 1907–1917, 2018. URL https://aclanthology.info/papers/P18-1177/p18-1177.
+
+Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. In INTERSPEECH 2014, 15th Annual Conference of the International Speech Communication Association, Singapore, September 14-18, 2014, pp. 2635–2639, 2014. URL http://www. isca-speech.org/archive/interspeech_2014/i14_2635.html.
+
+Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. arXiv preprint arXiv:1704.00051, 2017.
+
+Michael Collins. Three generative, lexicalised models for statistical parsing. In 35th Annual Meeting of the Association for Computational Linguistics and 8th Conference of the European Chapter of the Association for Computational Linguistics, Proceedings of the Conference, 7-12 July 1997, Universidad Nacional de Educacion a Distancia (UNED), Madrid, Spain. ´ , pp. 16–23, 1997. URL http://aclweb.org/anthology/P/P97/P97-1003.pdf.
+
+Yann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 933–941, 2017. URL http://proceedings.mlr.press/v70/dauphin17a.html.
+
+Xinya Du, Junru Shao, and Claire Cardie. Learning to ask: Neural question generation for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1342–1352, 2017. URL https://doi.org/10.18653/v1/P17-1123.
+
+Nan Duan, Duyu Tang, Peng Chen, and Ming Zhou. Question generation for question answering. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 866–874, 2017. URL https: //aclanthology.info/papers/D17-1090/d17-1090.
+
+Chris Dyer, Adhiguna Kuncoro, Miguel Ballesteros, and Noah A. Smith. Recurrent neural network grammars. In NAACL HLT 2016, The 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, San Diego California, USA, June 12-17, 2016, pp. 199–209, 2016. URL http://aclweb.org/anthology/N/ N16/N16-1024.pdf.
+
+Abdessamad Echihabi and Daniel Marcu. A noisy-channel approach to question answering. In Proceedings of the 41st Annual Meeting of the Association for Computational Linguistics, 7- 12 July 2003, Sapporo Convention Center, Sapporo, Japan., pp. 16–23, 2003. URL http: //aclweb.org/anthology/P/P03/P03-1003.pdf.
+
+Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pp. 1019–1027, 2016.
+
+Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA matter: Elevating the role of image understanding in visual question answering. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 6325–6334, 2017. URL https://doi.org/10.1109/CVPR.2017. 670.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 770–778, 2016. URL https://doi.org/10.1109/ CVPR.2016.90.
+
+Luheng He, Kenton Lee, Omer Levy, and Luke Zettlemoyer. Jointly predicting predicates and arguments in neural semantic role labeling. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics, ACL 2018, Melbourne, Australia, July 15-20, 2018, Volume 2: Short Papers, pp. 364–369, 2018. URL https://aclanthology.info/papers/ P18-2058/p18-2058.
+
+Michael Heilman and Noah A. Smith. Good question! statistical ranking for question generation. In Human Language Technologies: The 2010 Annual Conference of the North American Chapter of the Association for Computational Linguistics, HLT ’10, pp. 609–617. Association for Computational Linguistics, 2010. ISBN 1-932432-65-5. URL http://dl.acm.org/citation. cfm?id=1857999.1858085.
+
+Minghao Hu, Yuxing Peng, Zhen Huang, Xipeng Qiu, Furu Wei, and Ming Zhou. Reinforced mnemonic reader for machine reading comprehension. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI 2018, July 13-19, 2018, Stockholm, Sweden., pp. 4099–4106, 2018. URL https://doi.org/10.24963/ijcai.2018/570.
+
+Drew A. Hudson and Christopher D. Manning. Compositional attention networks for machine reasoning. CoRR, abs/1803.03067, 2018. URL http://arxiv.org/abs/1803.03067.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 448–456, 2015. URL http://jmlr. org/proceedings/papers/v37/ioffe15.html.
+
+Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 2021–2031, 2017. URL https://aclanthology.info/papers/D17-1215/d17-1215.
+
+Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 1988–1997, 2017. URL https://doi.org/ 10.1109/CVPR.2017.215.
+
+Mandar Joshi, Eunsol Choi, Daniel S. Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1601–1611, 2017. URL https://doi.org/10. 18653/v1/P17-1147.
+
+Yoon Kim, Yacine Jernite, David Sontag, and Alexander M. Rush. Character-aware neural language models. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, February 12-17, 2016, Phoenix, Arizona, USA., pp. 2741–2749, 2016. URL http://www.aaai.org/ ocs/index.php/AAAI/AAAI16/paper/view/12489.
+
+Kenton Lee, Tom Kwiatkowski, Ankur P. Parikh, and Dipanjan Das. Learning recurrent span representations for extractive question answering. CoRR, abs/1611.01436, 2016. URL http: //arxiv.org/abs/1611.01436.
+
+Yikang Li, Nan Duan, Bolei Zhou, Xiao Chu, Wanli Ouyang, and Xiaogang Wang. Visual question generation as dual task of visual question answering. CoRR, abs/1709.07192, 2017. URL http: //arxiv.org/abs/1709.07192.
+
+Feng Liu, Tao Xiang, Timothy M. Hospedales, Wankou Yang, and Changyin Sun. ivqa: Inverse visual question answering. CoRR, abs/1710.03370, 2017. URL http://arxiv.org/abs/ 1710.03370.
+
+Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. CoRR, abs/1609.07843, 2016. URL http://arxiv.org/abs/1609.07843.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), June 21- 24, 2010, Haifa, Israel, pp. 807–814, 2010. URL http://www.icml2010.org/papers/ 432.pdf.
+
+Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, New Orleans, Louisiana, USA, February 2-7, 2018, 2018. URL https://www.aaai.org/ocs/index.php/AAAI/AAAI18/paper/view/16528.
+
+Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 2227–2237, 2018. URL https://aclanthology.info/ papers/N18-1202/n18-1202.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. 2018. URL http://openai-assets.s3. amazonaws.com/research-covers/language-unsupervised/language_ understanding_paper.pdf.
+
+Martin Raison, Pierre-Emmanuel Mazare, Rajarshi Das, and Antoine Bordes. Weaver: Deep co- ´ encoding of questions and documents for machine reading. arXiv preprint arXiv:1804.10490, 2018.
+
+Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100, $0 0 0 +$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 2383–2392, 2016. URL http://aclweb.org/anthology/D/D16/D16-1264.pdf.
+
+Pranav Rajpurkar, Robin Jia, and Percy Liang. Know what you don’t know: Unanswerable questions for squad. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics, ACL 2018, Melbourne, Australia, July 15-20, 2018, Volume 2: Short Papers, pp. 784– 789, 2018. URL https://aclanthology.info/papers/P18-2124/p18-2124.
+
+Marc-Antoine Rondeau and Timothy J. Hazen. Systematic error analysis of the stanford question answering dataset. In Proceedings of the Workshop on Machine Reading for Question Answering@ACL 2018, Melbourne, Australia, July 19, 2018, pp. 12–20, 2018. URL https: //aclanthology.info/papers/W18-2602/w18-2602.
+
+Mrinmaya Sachan and Eric P. Xing. Self-training for jointly learning to ask and answer questions. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 629–640, 2018. URL https: //aclanthology.info/papers/N18-1058/n18-1058.
+
+Min Joon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. CoRR, abs/1611.01603, 2016. URL http://arxiv.org/ abs/1611.01603.
+
+Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Halifax, NS, Canada, August 13 - 17, 2017, pp. 1047–1055, 2017. URL http://doi.acm.org/10.1145/3097983.3098177.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 2440–2448, 2015. URL http://papers.nips.cc/paper/ 5846-end-to-end-memory-networks.
+
+Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014. URL http://papers.nips.cc/paper/ 5346-sequence-to-sequence-learning-with-neural-networks.
+
+Charles A. Sutton and Andrew McCallum. An introduction to conditional random fields. Foundations and Trends in Machine Learning, 4(4):267–373, 2012. URL https://doi.org/10. 1561/2200000013.
+
+Duyu Tang, Nan Duan, Tao Qin, and Ming Zhou. Question answering and question generation as dual tasks. CoRR, abs/1706.02027, 2017. URL http://arxiv.org/abs/1706.02027.
+
+Duyu Tang, Nan Duan, Zhao Yan, Zhirui Zhang, Yibo Sun, Shujie Liu, Yuanhua Lv, and Ming Zhou. Learning to collaborate for question answering and asking. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 1564–1574, 2018. URL https://aclanthology.info/papers/ N18-1141/n18-1141.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 6000–6010, 2017. URL http: //papers.nips.cc/paper/7181-attention-is-all-you-need.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 2692–2700, 2015. URL http://papers.nips.cc/paper/5866-pointer-networks.
+
+Wenhui Wang, Nan Yang, Furu Wei, Baobao Chang, and Ming Zhou. Gated self-matching networks for reading comprehension and question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 189–198, 2017. URL https://doi.org/10.18653/v1/ P17-1018.
+
+Zhiguo Wang, Haitao Mi, Wael Hamza, and Radu Florian. Multi-perspective context matching for machine comprehension. CoRR, abs/1612.04211, 2016. URL http://arxiv.org/abs/ 1612.04211.
+
+Dirk Weissenborn, Georg Wiese, and Laura Seiffe. Making neural QA as simple as possible but not simpler. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), Vancouver, Canada, August 3-4, 2017, pp. 271–280, 2017. URL https:// doi.org/10.18653/v1/K17-1028.
+
+Caiming Xiong, Victor Zhong, and Richard Socher. $\mathrm { D C N + }$ : mixed objective and deep residual coattention for question answering. CoRR, abs/1711.00106, 2017. URL http://arxiv. org/abs/1711.00106.
+
+Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V. Le. Qanet: Combining local convolution with global self-attention for reading comprehension. CoRR, abs/1804.09541, 2018. URL http://arxiv.org/abs/1804.09541.
+
+Lei Yu, Phil Blunsom, Chris Dyer, Edward Grefenstette, and Tomas Kocisk ´ y. The neural noisy ´ channel. CoRR, abs/1611.02554, 2016. URL http://arxiv.org/abs/1611.02554.
+
+Xingdi Yuan, Tong Wang, C¸ aglar Gulc¸ehre, Alessandro Sordoni, Philip Bachman, Saizheng Zhang, ¨ Sandeep Subramanian, and Adam Trischler. Machine comprehension by text-to-text neural question generation. In Proceedings of the 2nd Workshop on Representation Learning for NLP, Rep4NLP@ACL 2017, Vancouver, Canada, August 3, 2017, pp. 15–25, 2017. URL https: //aclanthology.info/papers/W17-2603/w17-2603.
+
+Bolei Zhou, Yuandong Tian, Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Simple baseline for visual question answering. CoRR, abs/1512.02167, 2015. URL http://arxiv.org/ abs/1512.02167.
+
+# A TRAINING DETAILS
+
+# A.1 SQUAD MODEL
+
+Pre-processing Questions and answers were tokenized with a simple rule-based tokenizer. We ignored training examples whose answers did not correspond to words in our tokenization. We also found it helpful to append the article title as an additional sentence at the end of paragraphs, as frequently question words make use of an entity mentioned in the title that is not in the paragraph. Finally, we replace question words with similar words from the context (based on sharing word stems or low edit distance), which makes it easier for the model to explain rare words and typographical errors in questions by using the pointer mechanism.
+
+Architecture The encoder contains 2 answer-independent LSTM layers and 3 answer-dependent LSTM layers, all of hidden size 128. The decoder contains 9 blocks, all with hidden size $d = 2 5 6$ . We apply dropout $( p = 0 . 5 5 )$ to contextualised word representations, after encoder LSTM layers and after each decoder block (before residual connects). We also used word level dropout after contextualised embeddings for each encoder $( p = 0 . 1 )$ ) and decoder word $( p = 0 . 2 5 )$ ), and disallow use of the pointer mechanism with $p = 0 . 2 5$ . All dropout masks are fixed across time-steps (Gal & Ghahramani, 2016).
+
+Optimisation We train generatively with batches of 10 documents, using a cosine learning rate schedule with a period of 1 epoch, warming up over the first 5 epochs to a maximum learning rate of $1 0 ^ { - 4 }$ . During fine-tuning, we freeze the answer-independent context encoding and $p ( a | c )$ model, which both reduces memory requirements and makes learning more stable. If the correct answer is not in the beam, we make no update. Fine tuning uses stochastic gradient descent with single question batches, learning rate $5 * \bar { 1 } 0 ^ { - 5 }$ , and momentum 0.97.
+
+# A.2 CLEVR MODEL
+
+Architecture All hidden layers in the encoder have size 128. We use 3 blocks of convolution, batch normalisation, and ReLU activations. The first block uses a 1x1 convolution to project the pre-trained features to size 128, and the other blocks use 3x3 convolutions. We apply dropout with rate 0.1 to the pre-trained image features. In the decoder we use a dimension $d = 2 5 6$ with 6 decoder blocks, with dropout $\cdot p = 0 . 2 5 ,$ ) before residual connections.
+
+Optimisation We optimise with stochastic gradient descent with momentum 0.9, with an initial learning rate of 0.025 which is decayed by a factor of 5 when there is no improvement for 10 epochs. For generative training we use batch size 1024. For fine tuning, we use initial learning rate 0.001 and batch size 32.

parse/train/Bkx0RjA9tX/Bkx0RjA9tX_content_list.json

@@ -0,0 +1,1872 @@
+[
+    {
+        "type": "text",
+        "text": "GENERATIVE QUESTION ANSWERING: LEARNING TO ANSWER THE WHOLE QUESTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Mike Lewis & Angela Fan Facebook AI Research {mikelewis,angelafan}@fb.com ",
+        "bbox": [
+            183,
+            172,
+            457,
+            215
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            252,
+            544,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Discriminative question answering models can overfit to superficial biases in datasets, because their loss function saturates when any clue makes the answer likely. We introduce generative models of the joint distribution of questions and answers, which are trained to explain the whole question, not just to answer it. Our question answering (QA) model is implemented by learning a prior over answers, and a conditional language model to generate the question given the answer— allowing scalable and interpretable many-hop reasoning as the question is generated word-by-word. Our model achieves competitive performance with comparable discriminative models on the SQUAD and CLEVR benchmarks, indicating that it is a more general architecture for language understanding and reasoning than previous work. The model greatly improves generalisation both from biased training data and to adversarial testing data, achieving state-of-the-art results on ADVERSARIALSQUAD. ",
+        "bbox": [
+            233,
+            287,
+            764,
+            468
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            336,
+            520
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Question answering tasks are widely used for training and testing machine comprehension and reasoning (Rajpurkar et al., 2016; Joshi et al., 2017). However, high performance has been achieved with only superficial understanding, as models exploit simple correlations in the data (Weissenborn et al., 2017; Zhou et al., 2015). For example, in Visual QA (Agrawal et al., 2017), the answer to What colour is the grass? can be memorised as green without considering the image (Figure 1). ",
+        "bbox": [
+            174,
+            540,
+            823,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We argue that this over-fitting to biases is partly caused by discriminative loss functions, which saturate when simple correlations allow the question to be answered confidently, leaving no incentive for further learning on the example. ",
+        "bbox": [
+            176,
+            616,
+            821,
+            657
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We propose generative QA models, using Bayes’ rule to reparameterise the distribution of answers given questions in terms of the distribution of questions given answers. We learn a prior over answers and a conditional language model for generating the question—reducing question answering to sequence-to-sequence learning (Sutskever et al., 2014), and allowing many-hop reasoning as the model explains the whole question word-by-word. ",
+        "bbox": [
+            174,
+            665,
+            823,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative loss functions train the model to explain all question words, even if the answer is obvious. For example, a model cannot assign high probability to generating the question What colour is the grass? without learning a dependency between the image and the word grass. We show that this method allows much improved generalisation from biased training data and to adversarial test data, compared to state-of-the-art discriminative models. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            811
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Word-by-word generative modelling of questions also supports chains of reasoning, as each subpart of the question is explained in turn. Existing methods use a pre-specified number of reasoning steps (Sukhbaatar et al., 2015; Hudson & Manning, 2018), which may be too many steps on easy cases, and too few on long and complex questions. We instead perform an interpretable reasoning step for each question word, and achieve $9 7 . 7 \\%$ accuracy on the CLEVR benchmark (Johnson et al., 2017). ",
+        "bbox": [
+            174,
+            819,
+            825,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our approach opens a promising new direction for question answering, with strong results in language understanding, reasoning and generalisation. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/4ea3ae44df91abbf802dd70ffd949fe57baa29e2dc6df16e8c5ad6e7813f40b1.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            103,
+            447,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Does the green rubber object have the same shape as the gray thing that is on the right side of the big purple object? ",
+        "bbox": [
+            174,
+            261,
+            486,
+            303
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Is the purple thing the same shape as the large gray rubber thing? ",
+        "bbox": [
+            173,
+            233,
+            486,
+            260
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) Two CLEVR questions. Both can be answered no using only subsets of the available information. A generative model must learn to perform additional reasoning to assign high likelihood to the complete question-answer pair. Word-by-word question generation allows a reasoning step to explain each word. ",
+        "bbox": [
+            174,
+            308,
+            486,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Whilst filming in Mexico City, speculation in the media claimed that the script had been altered to accommodate the demands of Mexican authorities reportedly influencing details of the scene and characters, casting choices, and modifying the script in order to portray the country in a “positive light” in order to secure tax concessions and financial support worth up to $\\$ 20$ million for the film. This was denied by producer Michael G. Wilson. ",
+        "bbox": [
+            517,
+            104,
+            834,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Which Bond producer would not confirm that the film had been changed to accommodate Mexican authorities? ",
+        "bbox": [
+            509,
+            251,
+            825,
+            292
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(b) A SQUAD question. A discriminative model can identify the only producer, and ignore the rest of the question. To generate the question and answer, our model needs coreference, negation and paraphrasing. These reasoning skills can improve generalisation on test examples with multiple plausible answers. ",
+        "bbox": [
+            511,
+            309,
+            825,
+            385
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1: Examples of questions that can be answered using only some question words (underlined). ",
+        "bbox": [
+            173,
+            397,
+            821,
+            411
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            435,
+            267,
+            452
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            465,
+            290,
+            481
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We assume a dataset of examples with a question $q = q _ { 0 . . T }$ , answer $a$ , and context $c$ (in our experiments, $c$ is a document or image, but alternatives such as knowledge graphs could be used). ",
+        "bbox": [
+            173,
+            492,
+            821,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We train models to minimize the negative log likelihood of the joint distribution of questions and answers given the context, $- \\log p ( q , a | c )$ , which we decompose using the chain rule as: ",
+        "bbox": [
+            173,
+            527,
+            821,
+            556
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d1ef33dec521c7a938e6febd181770e9f42293b7957ce765effe0ec05f3b656.jpg",
+        "text": "$$\n\\mathcal { L } = - \\log p ( a | c ) - \\sum _ { t } \\log p ( q _ { t } | a , c , q _ { 0 . . t - 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            560,
+            648,
+            593
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "First $c$ is encoded, using a recurrent model for text $( \\ S 2 . 2 )$ and a using a convolutional model for images (§2.3). ",
+        "bbox": [
+            171,
+            604,
+            825,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Then, a prior over answers $p ( a | c )$ is evaluated by scoring all possible answers (2.4). ",
+        "bbox": [
+            179,
+            640,
+            727,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The likelihood of the question $p ( q | a , c )$ is modelled using a conditional language model (§2.5). ",
+        "bbox": [
+            173,
+            661,
+            794,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "At test time, the answer maximizing $p ( q , a | c )$ is returned1 (§2.7). ",
+        "bbox": [
+            173,
+            683,
+            601,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameters and training details are fully described in Appendix A. ",
+        "bbox": [
+            176,
+            704,
+            647,
+            719
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 DOCUMENT ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            734,
+            370,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Answer-independent Context Representation We use contextualised word representations, similar to ELMo (Peters et al., 2018). We use character-based word embeddings (Kim et al., 2016) and train a 2-layer LSTM language model in the forward and reverse directions, using the WikiText-103 corpus (Merity et al., 2016) for domain-specificity2. These parameters are frozen, and not finetuned. Contextualised word representations are computed as a fully connected layer applied to the concatenation of the word embedding and the hidden states of each layer of the language model. We sum this representation with a trainable vector of size $d$ if the word occurs in the article title, giving the encoder information about the article topic. We follow this with bidirectional LSTMs of size $d / 2$ , concatenating the output in each direction and adding residual connections after each layer. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "What we now call gravity was not identified as a universal force until the work of Isaac Newton. [...] Galileo was instrumental in describing the characteristics of falling objects [...] this acceleration due to gravity towards the surface of the Earth is usually designated as and has a magnitude of about 9.81 meters per second squared [...], and points toward the center of the Earth. [...] Distractor: Object falls about 5 times faster on Mars. ",
+        "bbox": [
+            179,
+            107,
+            485,
+            250
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/11e6c9fa19f967ab01fb9398ccc26793a802ffce483743e59f947b1cb08b413a.jpg",
+        "image_caption": [
+            "Figure 2: Probabilities of generating question words given different answers for a standard and an adversarial SQUAD question, allowing us to interpret which questions words are explained by the answer. In the standard setting, the model places greater probability on the question words that appear near Isaac Newton, such as force compared to Galileo. In the adversarial setting, the question word Earth distinguishes the true answer from the distractor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            517,
+            106,
+            813,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Answer Encoder We assume answers $a$ are a span $i . . j$ of the document. We represent the answer as a weighted sum of words within the span. For each word representation $\\begin{array} { r } { \\sum _ { k = i \\ldots j } \\sigma ( w \\cdot \\tilde { c } _ { k } ) \\tilde { c } _ { k } } \\end{array}$ , where $w \\in R ^ { d }$ is a trainable vector, and $\\tilde { c } _ { k }$ is the kth word in the answer-independent document representation. In contrast to previously proposed span representations (Lee et al., 2016; He et al., 2018), this approach allows the model to select arbitrarily many head words from the span. ",
+        "bbox": [
+            173,
+            372,
+            825,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Answer-dependent Context Representation Generative training makes it feasible to model more complex interactions between the answer and context than discriminative training, because only the correct answer is used. On SQUAD, we compute an answer-dependent document representation. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            511
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we take the output of the answer-independent representation of each context word, and concatenate it with 32-dimensional embeddings of: a binary feature for whether the word is contained in the answer, its position relative to the answer start, and its position relative to the answer end. We also concatenate the element-wise product of the word representation and the answer encoding. We feed the result into 3 further layers of residual bidirectional LSTMs of size $d / 2$ . ",
+        "bbox": [
+            174,
+            518,
+            825,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 IMAGE ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            613,
+            334,
+            628
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We use a simple image encoder, leaving reasoning to the question decoder. ",
+        "bbox": [
+            176,
+            643,
+            661,
+            657
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Following Johnson et al. (2017), we take pre-trained features from the conv4 layer ResNet-101 model (He et al., 2016), giving 1024-dimensional features for a $1 4 \\mathrm { x } 1 4$ image grid. We apply dropout, and project these representations to size $d$ using a 1x1 convolution, followed by batch normalisation (Ioffe & Szegedy, 2015) and a ReLU activation (Nair & Hinton, 2010). We then use 2 blocks of $3 { \\tt X } 3$ convolutions, batch normalisation and ReLUs, and concatenate the final representation with a 32-dimensional positional encoding. ",
+        "bbox": [
+            174,
+            664,
+            825,
+            748
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 ANSWER PRIOR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            773,
+            325,
+            787
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We found modelling $p ( a | c )$ , the distribution over answers given the context, to be straightforward. ",
+        "bbox": [
+            171,
+            803,
+            813,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On SQUAD, we concatenate the start and end representations of the answer-independent context representation, combine them with a single hidden layer of size $2 d$ and ReLU activation, and project this representation down to a score $s ^ { \\mathrm { e n d p o i n t s } } ( a , c )$ . We also add an additional score based only on the length of the answer $s ^ { \\mathrm { l e n g t h } } ( a )$ . Finally, we calculate: $\\begin{array} { r } { p ( a | c ) = \\frac { \\exp { ( s ^ { \\mathrm { e n d p o i n t s } } ( a , c ) + s ^ { \\mathrm { l e n g t h } } ( a ) ) } } { \\sum _ { a ^ { \\prime } } \\exp { ( s ^ { \\mathrm { e n d p o i n t s } } ( a ^ { \\prime } , c ) + s ^ { \\mathrm { l e n g t h } } ( a ^ { \\prime } ) ) } } } \\end{array}$ ",
+        "bbox": [
+            174,
+            824,
+            825,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "On CLEVR, we simply apply a fully connected layer of size $2 d$ and ReLU activation to the image representation, followed by a projection to the space of all possible answers and a softmax. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/54abe8f1cd06caa9b40dbab56e9c8335e02379b89c46c2e60fc4a281b7e382e3.jpg",
+        "image_caption": [
+            "Figure 3: Architecture of GQA decoder. Multiple inputs to a layer indicates concatenation. Blocks after the first are connected with an additional residual connection, and LSTM cells also receive their state at time $t - 1$ as an input. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            245,
+            103,
+            756,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5 QUESTION DECODER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            385,
+            361,
+            400
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We generate question words left-to-right with teacher forcing. We first embed words independently of the context (§2.5.1), then use a multi-layer RNN with attention to model interactions between the question and context $( \\ S 2 . 5 . 2 )$ , and finally compute the likelihood of the next word (§2.5.3). ",
+        "bbox": [
+            174,
+            412,
+            825,
+            455
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5.1 INPUT WORD EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            476,
+            421,
+            489
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To represent SQUAD question words independently of the answer and document, we use a pretrained left-to-right language model (which can be viewed as a uni-directional version of ELMo), followed by a trainable LSTM layer of size $d$ . On CLEVR, we simply train embeddings of size $d$ . ",
+        "bbox": [
+            176,
+            502,
+            823,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5.2 DECODER BLOCKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            564,
+            361,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Decoder blocks are composed of a question self-attention layer (Vaswani et al., 2017) and a questionto-context attention mechanism, which are combined and fed into an LSTM (Figure 3). The context attention query is computed using both the previous layer state and the self-attention value. Blocks after the first are connected with residual connections. ",
+        "bbox": [
+            176,
+            590,
+            825,
+            646
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our attention mechanisms are implemented as in Vaswani et al., except that we use a single-headed attention, and a bias term $b _ { j }$ is added to the query-key score for context position $j$ . This bias term (calculated as a dot product of a shared trainable vector and context encoding $c _ { j }$ ) allows the model to easily filter out parts of the context which are irrelevant to the question. ",
+        "bbox": [
+            174,
+            654,
+            823,
+            709
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A final block again uses self-attention and question-to-document attention, which are then combined with a Gated Linear Unit layer (Dauphin et al., 2017) to output a vector of size $d$ . The GLU layer uses a gating mechanism to select the relevant information for predicting the subsequent word. ",
+        "bbox": [
+            176,
+            717,
+            823,
+            758
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.5.3 OUTPUT WORD PROBABILITIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            447,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Rare words are more challenging for generative than discriminative models, because it is easier to guess the meaning of a rare word from morphological clues than to generate it. SQUAD contains many rare words, because of the specialised vocabulary in Wikipedia. We improve modelling of rare words using a combination of an approximate character-based softmax and copy mechanism. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Word Softmax The simplest approach is to learn an embedding per word, replacing infrequent words with an unknown token. This approach cannot discriminate between different rare words. We use this method on CLEVR, which has a small vocabulary. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/57145f9925bdfa9d12c796b1ebbe1a25908c21eec1e131efb7b0370bb907722f.jpg",
+        "image_caption": [
+            "Figure 4: Final layer attention maps and word probabilities during question generation on a CLEVR validation question, when predicting the highlighted word. (1) The model considers all the rubber objects for predicting the next word. (2) Objects to the left of a rubber object are considered. (3) It describes the brown cylinder. (4, 5) Word distributions show the model understands the next words, but interestingly its attention focuses on the set of two objects meeting the constraints. In all cases, the word probability distributions are heavily skewed towards semantically valid choices. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            821,
+            292
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Character Softmax While there is an infinite space of possible output words, we approximate it by only normalising over the union of a list of frequent words, and any additional word that appears in any question or any document in the batch. We build a character-based representation for each candidate word using the pre-trained character CNN from $\\ S 2 . 2$ , and add a trainable linear projection to size $d$ . We combine character-based and word-based representations by summation. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pointer Mechanism We use a pointer mechanism (Vinyals et al., 2015) to improve the likelihood of the specialised vocabulary present in SQUAD, by copying article words. From the final hidden state $h _ { t }$ , the model first chooses whether to copy using a simple classifier $p ^ { \\mathrm { c o p y } } ( h ) = \\sigma ( w ^ { \\mathrm { c o p y } } \\cdot h ) .$ , where $w ^ { \\mathrm { c o p y } }$ is a trainable vector of size $d$ . Then, the model interpolates between generating a word with softmax $p ^ { \\mathrm { g e n } } ( h )$ and copying context word $c _ { i }$ using the question-to-context attention probability from the final layer $\\dot { \\alpha } _ { t } ^ { i }$ : $p ( q _ { t } \\vert \\mathbf { \\bar { q } } _ { 0 : t - 1 } , c , a ) = p ^ { \\mathrm { c o p y } } ( h _ { t } ) \\sum _ { i } \\alpha _ { t } ^ { i } \\hat { \\mathbb { 1 } } _ { c _ { i } = q _ { t } } + ( 1 - p ^ { \\mathrm { c o p y } } ( h _ { t } ) ) p ^ { \\mathrm { g e n } } \\mathbf { \\bar { ( } } q _ { t } | h _ { t } )$ ",
+        "bbox": [
+            174,
+            510,
+            825,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.6 FINE TUNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            614,
+            310,
+            628
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Generative training using teacher forcing means that the model is not exposed to negative combinations of questions and answers at training time, so performance on these combinations may be weak when used for inference. For example, the model can overfit as a language model on questions, and ignore dependencies to the answer. Results can be improved by fine-tuning the model to make the question more likely under the gold answer than other plausible answers. Here, we minimize $- \\log \\frac { p ( q | a , c ) p ( a | \\bar { c } ) } { \\sum _ { a ^ { \\prime } \\in A } p ( q | a ^ { \\prime } , c ) p ( a ^ { \\prime } | c ) }$ , where $A$ is the most likely 100 answer candidates from $p ( a | c )$ . The model performs poorly when trained using only this loss function, suggesting that generative pretraining allows the model to establish complex dependencies between the input and output, which can then be calibrated discriminatively (Table 2). ",
+        "bbox": [
+            173,
+            641,
+            825,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.7 INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            804,
+            295,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We return the answer $a ^ { * }$ maximizing $a ^ { * } = \\mathrm { a r g m a x } _ { a } p ( q | a , c ) p ( a | c )$ , which requires evaluating the likelihood of the given question under each possible answer. ",
+        "bbox": [
+            174,
+            832,
+            821,
+            861
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To efficiently handle the large number of possible answers in SQUAD, we use beam search. We evaluate $p ( a | c )$ for all possible answer spans up to length 30, take the top 250 candidates, and only evaluate $p ( q | a , c )$ for each of these. A correct answer is contained in the beam for over $9 8 . 5 \\%$ o f validation questions, suggesting that approximate inference is not a major cause of errors. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/03b4c01c34f047187994357641629b5f2b6ef7de102ee20139983ffe8106acfe.jpg",
+        "table_caption": [
+            "Table 1: Exact Match (EM) and F1 on SQUAD, comparing to the best published single models at the time of submission (September 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Single Model</td><td colspan=\"2\">Development</td><td colspan=\"2\">Test</td></tr><tr><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>RaSOR (Lee et al., 2016)</td><td>66.4</td><td>74.9</td><td>67.4</td><td>75.5</td></tr><tr><td>BiDAF (Seo et al., 2016)</td><td>67.7</td><td>77.3</td><td>68.0</td><td>77.3</td></tr><tr><td>DrQA (Chen et al., 2017)</td><td>69.5</td><td>78.8</td><td>70.7</td><td>79.3</td></tr><tr><td>R-Net (Wang et al., 2017)</td><td>71.1</td><td>79.5</td><td>72.3</td><td>80.7</td></tr><tr><td>Weaver (Raison et al., 2018)</td><td>74.1</td><td>82.4</td><td>74.4</td><td>82.8</td></tr><tr><td>DCN+ (Xiong et al., 2017)</td><td>74.5</td><td>83.1</td><td>75.1</td><td>83.1</td></tr><tr><td>QANet + data augmentation x3 (Yu et al., 2018)</td><td>75.1</td><td>83.8</td><td>76.2</td><td>84.6</td></tr><tr><td>BiDAF + Self Attention + ELMo (Peters et al., 2018)</td><td>=</td><td>85.6</td><td>78.6</td><td>85.8</td></tr><tr><td>Reinforced Mnemonic Reader (Hu et al., 2018)</td><td>78.9</td><td>86.3</td><td>79.5</td><td>86.6</td></tr><tr><td>GQA</td><td>76.8</td><td>83.7</td><td>77.1</td><td>83.9</td></tr></table>",
+        "bbox": [
+            210,
+            98,
+            789,
+            270
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/87d7ce27af23d0cb69a1b10615a69cf978d8e29584e304b5b6a0f0f0ae64f097.jpg",
+        "table_caption": [
+            "Table 2: Development results on SQUAD for model ablations. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Single Model</td><td>Exact Match</td><td>F1</td></tr><tr><td>GQA</td><td>76.8</td><td>83.7</td></tr><tr><td>GQA (no fine-tuning)</td><td>72.3</td><td>80.1</td></tr><tr><td>GQA (no generative training)</td><td>64.5</td><td>72.2</td></tr><tr><td>GQA (no character-based softmax)</td><td>74.3</td><td>81.4</td></tr><tr><td>GQA (no pointer mechanism)</td><td>71.9</td><td>79.7</td></tr><tr><td>GQA (no answer-dependent context representation)</td><td>72.2</td><td>79.7</td></tr><tr><td>GQA (answer prior only)</td><td>13.4</td><td>16.1</td></tr></table>",
+        "bbox": [
+            236,
+            329,
+            759,
+            454
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            491,
+            328,
+            508
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 LARGE-SCALE READING COMPREHENSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            523,
+            514,
+            539
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our model (GQA) on the SQUAD dataset to test its robustness to diverse syntactic and lexical inferences. Results are shown in Table 1, and are competitive with comparable discriminative models, despite several years of incremental progress on discriminative architectures for this task. These results show the potential of generative models for such tasks. ",
+        "bbox": [
+            174,
+            550,
+            825,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Higher results have been reported using techniques such as ensembles, data augmentation, reinforcement learning with the end-task metric a reward, and breakthroughs in unsupervised pre-training. ",
+        "bbox": [
+            171,
+            613,
+            823,
+            641
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows several ablations. It demonstrates the importance of the character-based softmax and pointer mechanism for modelling rare words, the need to model interactions between the answer and context, and a large improvement from fine-tuning the model with negative question-answer pairs. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The ablations also highlight that while fine-tuning the model with a discriminative objective substantially improves the results, performance is weak when trained discriminatively from scratch. This result suggests that generative training is learning additional relationships, but can benefit from being calibrated and exposed to negative question-answer pairs during fine tuning. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows an ablation study for the number of answer candidates considered in the beam of possible answers at inference time. Considering a larger number of answer candidates improves results, but increases the computational cost as the likelihood of the question must be calculated for each candidate. ",
+        "bbox": [
+            174,
+            761,
+            825,
+            815
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 MULTIHOP REASONING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            379,
+            848
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the ability of our model to perform multihop reasoning on the CLEVR dataset, which consists of images paired with automatically generated questions involving that test visual reasoning. ",
+        "bbox": [
+            174,
+            859,
+            821,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 4 shows that GQA achieves an accuracy of $9 7 . 7 \\%$ , compared to $7 6 . 6 \\%$ for a standard visual QA model, demonstrating that our generative architecture can perform complex reasoning. Integrat",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/5c2c364a705f82ecbe53a093dc03726e7b93221ce987b9ba5f6858119ebe032c.jpg",
+        "table_caption": [
+            "Table 3: Development results on SQUAD, varying the beam size during inference. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>#Answer Candidates</td><td>Exact Match</td><td>F1</td></tr><tr><td>250</td><td>76.8</td><td>83.7</td></tr><tr><td>200</td><td>76.6</td><td>83.4</td></tr><tr><td>100</td><td>76.2</td><td>83.1</td></tr><tr><td>50</td><td>74.6</td><td>81.4</td></tr><tr><td>10</td><td>55.7</td><td>61.4</td></tr></table>",
+        "bbox": [
+            336,
+            99,
+            663,
+            186
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e67686d367a8502f70fe6a56c7c14908732d07857f130c478cd89b25b824970.jpg",
+        "table_caption": [
+            "Table 4: Test results on CLEVR, demonstrating high accuracy at complex reasoning. GQA is the first approach to achieve high performance on both CLEVR and broad coverage QA tasks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Single Model</td><td>Overall</td><td>Count</td><td>Exist</td><td>Compare Numbers</td><td>Query Attribute</td><td>Compare Attribute</td></tr><tr><td>Human</td><td>92.6</td><td>86.7</td><td>96.6</td><td>86.5</td><td>95.0</td><td>96.0</td></tr><tr><td>CNN+LSTM</td><td>52.3</td><td>43.7</td><td>65.2</td><td>67.1</td><td>49.3</td><td>53.0</td></tr><tr><td>CNN+LSTM+SA</td><td>76.6</td><td>64.4</td><td>82.7</td><td>77.4</td><td>82.6</td><td>75.4</td></tr><tr><td>CNN+LSTM+RN</td><td>95.5</td><td>90.1</td><td>97.8</td><td>93.6</td><td>97.9</td><td>97.1</td></tr><tr><td>CNN+GRU+FiLM</td><td>97.6</td><td>94.3</td><td>99.3</td><td>93.4</td><td>99.3</td><td>99.3</td></tr><tr><td>MAC</td><td>98.9</td><td>97.1</td><td>99.5</td><td>99.1</td><td>99.5</td><td>99.5</td></tr><tr><td>GQA</td><td>97.7</td><td>94.9</td><td>98.3</td><td>97.0</td><td>99.2</td><td>99.2</td></tr></table>",
+        "bbox": [
+            200,
+            233,
+            795,
+            363
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "ing MAC cells (Hudson & Manning, 2018) into our decoder or FiLM layers (Perez et al., 2018) into our encoder would be straightforward, and may improve results, but we avoid these techniques to emphasise that generative decoding alone allows multihop reasoning. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            479
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows an example of how the model decomposes the reasoning over the question. It initially pays attention to all shapes, but updates its attention mask after new words are read. ",
+        "bbox": [
+            174,
+            487,
+            821,
+            515
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 LEARNING FROM BIASED DATA ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            434,
+            549
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many popular QA datasets are well known to contain biases that models can exploit. Examples include when questions paired with paragraphs that contain a single date. Models can exploit biases by learning simple heuristics such as selecting answers based on the expected answer type (Weissenborn et al., 2017; Rondeau & Hazen, 2018). Recent work has attempted to remove some biases (Goyal et al., 2017; Rajpurkar et al., 2018); we instead attempt to make training robust to bias. ",
+        "bbox": [
+            174,
+            563,
+            823,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We create deliberately biased training subsets of SQUAD based on named entity types: numbers, dates, and people. To construct each training set, we select questions whose answer is one of these types, but that type only appears once in the document (e.g. Figure 1b). The validation set is created from questions whose answers are the named entity type, but there must be multiple occurrences of that type in the document. Each training and validation set contains rougly 1000 questions. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            708
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We compare our model to two strong discriminative models, BiDAF (Seo et al., 2016) and QANet3 (Yu et al., 2018). We also report three question agnostic baselines: a random answer of the correct type, the first answer of the correct type, and the GQA answer prior distribtion. ",
+        "bbox": [
+            176,
+            715,
+            823,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Results are shown in Table 5, and show that discriminatively trained models perform similarly to question-agnostic baselines. In contrast, our generative model learns to generalise meaningfully even from highly biased data, because it is trained to explain the whole question, not simply to answer it—demonstrating that on some QA tasks, there are clear advantages to generative modelling. ",
+        "bbox": [
+            174,
+            763,
+            825,
+            820
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 ADVERSARIAL EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            411,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate on an adversarial version of the SQUAD dataset (Jia & Liang, 2017), which was created by adding a distractor sentence to each paragraph that can almost answer the question. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            896
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8fe1d1eaeed4e69ea8a66ddb72ab1dc6ee239ae468c884935c0c9302b24803d0.jpg",
+        "table_caption": [
+            "Table 5: Exact Match (EM) and F1 on biased subsets of SQUAD. All answers in each subset have the indicated named-entity type; training documents have only one answer with this type, but for testing there are multiple plausible answers. Discriminative models perform comparably to questionagnostic baselines, whereas our generative model learns to generalise. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Single Model</td><td colspan=\"2\">Numbers</td><td colspan=\"2\">Dates</td><td colspan=\"2\">People</td></tr><tr><td>EM</td><td>F1</td><td>EM</td><td>F1</td><td>EM</td><td>F1</td></tr><tr><td>Random Selection First Occurrence</td><td>19.37 29.36</td><td>26.18 35.11</td><td>19.37 34.64</td><td>26.18</td><td>19.37</td><td>26.18</td></tr><tr><td>BiDAF</td><td>33.02</td><td>42.14</td><td>35.41</td><td>42.08 43.83</td><td>26.38 30.05</td><td>32.26 37.28</td></tr><tr><td>QANet</td><td>31.99</td><td>40.58</td><td>39.98</td><td>47.82</td><td>30.26</td><td>38.56</td></tr><tr><td>GQA (answer prior only)</td><td>37.15</td><td>45.54</td><td>35.55</td><td>43.85</td><td>32.56</td><td>38.79</td></tr><tr><td>GQA</td><td>58.49</td><td>67.56</td><td>64.71</td><td>72.51</td><td>53.09</td><td>61.93</td></tr></table>",
+        "bbox": [
+            235,
+            99,
+            764,
+            220
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/7798f5ba176cc5d87f4ada851cbcb3a8f32627d53e9b44efffeaa28f0c52d508.jpg",
+        "table_caption": [
+            "Table 6: F1 scores on ADVERSARIALSQUAD (from September 2018), which demonstrate that our generative QA model is substantially more robust to this adversary than previous work, likely because the additional adversarial context sentence cannot explain all the question words. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Single Model</td><td>ADDSENT</td><td>ADDONESENT</td></tr><tr><td>BiDAF (Seo et al.,2016)</td><td>34.3</td><td>45.7</td></tr><tr><td>RaSOR (Lee et al., 2016)</td><td>39.5</td><td>49.5</td></tr><tr><td>MPCM (Wang et al., 2016)</td><td>40.3</td><td>50.0</td></tr><tr><td>ReasoNet (Shen etal., 2017)</td><td>39.4</td><td>50.3</td></tr><tr><td>Reinforced Mnemonic Reader (Hu et al., 2018)</td><td>46.6</td><td>56.0</td></tr><tr><td>QANet (Yu et al., 2018)</td><td>45.2</td><td>55.7</td></tr><tr><td>GQA</td><td>47.3</td><td>57.8</td></tr></table>",
+        "bbox": [
+            223,
+            292,
+            772,
+            409
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 6 shows that GQA outperforms the best previous work by up to $2 . 1 \\ \\mathrm { F 1 }$ , making it the most robust model to these adversarial attacks. The improvement may be due to the model’s attempt to explain all question words, some of which may be unlikely under the distractor (Figure 2). ",
+        "bbox": [
+            174,
+            500,
+            825,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.5 LONG CONTEXT QUESTION ANSWERING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            564,
+            498,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we extend our generative model to answering questions in a more challenging, multiparagraph setting. While we train on single paragraphs, our model can be used to answer questions with multi-paragraph context. During training, our model $p ( q \\mid a , c )$ depends only on the content of the paragraph $c$ containing the correct answer $a$ . In contrast, discriminative models need to be trained to discriminate against all negative answers from all paragraphs. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            661
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We use the multi-paragraph SQUAD dataset of Raison et al. (2018), where each question is paired with the entire corresponding Wikipedia article. For each question, we calculate $p ( q \\mid a ) s ( a , c )$ for the proposed answer span $a$ produced by the model, where $s ( a , c )$ is the logits from the answer prior classifier. The maximum value across all paragraphs of that article is selected as the answer for that question. Table 7 shows that GQA outperforms previous work on this task by $2 . 5 \\ : \\mathrm { F 1 }$ . Further, discriminative models such as DrQA and Weaver require training in the multi-paragraph setting to perform well, which is expensive and may not scale to longer contexts. However, our generative approach performs well in the multi-paragraph test setting but only requires single paragraph training. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            780
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            805,
+            344,
+            821
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Our model is inspired by the classic noisy channel translation models of Brown et al. (1993), more recently explored by Yu et al. (2016), which were motivated by the ease of incorporating a prior over outputs. Generative models have been widely used in other language classification tasks, such as sequence tagging (Brants, 2000) and parsing (Collins, 1997; Dyer et al., 2016). Generative classification models became less popular because of the difficulty of modelling the input (Sutton & McCallum, 2012), a challenge we embrace as an additional learning signal. Recent work has shown the effectiveness of generative pre-training on unlabelled data (Peters et al., 2018; Radford et al., 2018), we show additional gains from training generatively on labelled data. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5786ce4c6622a7133f2b86a39ff8c54ef1b5fea48bdc330ad58bf46c705b771e.jpg",
+        "table_caption": [
+            "Table 7: F1 scores on full document evaluation for SQUAD, which show our generative QA model is capable of selecting the correct paragraph for question answering even when presented with other similar paragraphs. Baselines are from (Raison et al., 2018). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Single Model EM F1</td></tr><tr><td>DrQA* trained on paragraph 59.1 67.0 Weaver trained on paragraph 60.6 69.7</td></tr><tr><td>DrQA* trained on documents 64.7 73.2</td></tr><tr><td>Weaver trained on documents 67.0 75.9 GQA trained on paragraph 71.4 78.4</td></tr></table>",
+        "bbox": [
+            341,
+            99,
+            656,
+            188
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            279,
+            821,
+            308
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Several studies have explored the relationship between question answering and question generation. Duan et al. (2017) and Tang et al. (2017) train answering and generation models with separate parameters, but add a regularisation term that encourages the models to be consistent. They focus on answer sentence selection, so performance cannot easily be compared with our work. Tang et al. (2018) use question generation to provide an additional loss to improve question answering systems using GAN-like training. Li et al. (2017) apply similar techniques to visual QA. Our work differs in training a single model for the joint distribution of questions and answers, which can be used to calculate conditional distributions for question generation or answering. Sachan & Xing (2018) improve performance by generating new question-answer pairs for training from unlabelled text, which would be a possible extension to our work. Echihabi & Marcu (2003) describe an earlier method for answering questions in terms of the distribution of questions given answers—one conceptual difference is that their approach does not include a prior over answers. ",
+        "bbox": [
+            174,
+            314,
+            825,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Question generation has also been studied as a task in its own right. Heilman & Smith (2010) use a rule-based system to generate candidate questions, followed by statistical ranking. Du et al. (2017) use a sequence-to-sequence model that encodes paragraph and sentence level information to generate questions. Cardie & Du (2018) propose using a coreference mechanism to incorporate contextual information from multiple sentences. Liu et al. (2017) explore question generation from images, which they refer to as Inverse Visual QA. Yuan et al. (2017) fine-tune a question generation model using reinforcement learning, based on fluency and whether it can be answered. Although we train a question generation model, our focus is on using it to answer questions. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            318,
+            640
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We introduced a generative model for question answering, which leverages the greater amount of information in questions than answers to achieve high performance in both language comprehension and reasoning. The approach demonstrates better robustness to biased training data and adversarial testing data than state-of-the-art discriminative models. There are numerous interesting directions for future work, such as combining information about an entity from multiple sources to generate questions. Given the rapid progress made on discriminative QA models in recent years, we believe there is significant potential for further improvements in generative question answering. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            285,
+            796
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aishwarya Agrawal, Jiasen Lu, Stanislaw Antol, Margaret Mitchell, C. Lawrence Zitnick, Devi Parikh, and Dhruv Batra. Vqa: Visual question answering. Int. J. Comput. Vision, 123(1):4–31, May 2017. ISSN 0920-5691. URL https://doi.org/10.1007/ s11263-016-0966-6. ",
+        "bbox": [
+            176,
+            808,
+            825,
+            863
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thorsten Brants. TnT: a statistical part-of-speech tagger. In Proceedings of the sixth conference on Applied natural language processing, pp. 224–231. Association for Computational Linguistics, 2000. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Peter F. Brown, Stephen Della Pietra, Vincent J. Della Pietra, and Robert L. Mercer. The mathematics of statistical machine translation: Parameter estimation. Computational Linguistics, 19(2): 263–311, 1993. ",
+        "bbox": [
+            173,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Claire Cardie and Xinya Du. Harvesting paragraph-level question-answer pairs from wikipedia. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics, ACL 2018, Melbourne, Australia, July 15-20, 2018, Volume 1: Long Papers, pp. 1907–1917, 2018. URL https://aclanthology.info/papers/P18-1177/p18-1177. ",
+        "bbox": [
+            173,
+            157,
+            825,
+            214
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ciprian Chelba, Tomas Mikolov, Mike Schuster, Qi Ge, Thorsten Brants, Phillipp Koehn, and Tony Robinson. One billion word benchmark for measuring progress in statistical language modeling. In INTERSPEECH 2014, 15th Annual Conference of the International Speech Communication Association, Singapore, September 14-18, 2014, pp. 2635–2639, 2014. URL http://www. isca-speech.org/archive/interspeech_2014/i14_2635.html. ",
+        "bbox": [
+            173,
+            226,
+            825,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Danqi Chen, Adam Fisch, Jason Weston, and Antoine Bordes. Reading wikipedia to answer opendomain questions. arXiv preprint arXiv:1704.00051, 2017. ",
+        "bbox": [
+            173,
+            308,
+            820,
+            337
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Collins. Three generative, lexicalised models for statistical parsing. In 35th Annual Meeting of the Association for Computational Linguistics and 8th Conference of the European Chapter of the Association for Computational Linguistics, Proceedings of the Conference, 7-12 July 1997, Universidad Nacional de Educacion a Distancia (UNED), Madrid, Spain. ´ , pp. 16–23, 1997. URL http://aclweb.org/anthology/P/P97/P97-1003.pdf. ",
+        "bbox": [
+            173,
+            348,
+            826,
+            419
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann N. Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated convolutional networks. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 933–941, 2017. URL http://proceedings.mlr.press/v70/dauphin17a.html. ",
+        "bbox": [
+            174,
+            430,
+            825,
+            487
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xinya Du, Junru Shao, and Claire Cardie. Learning to ask: Neural question generation for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1342–1352, 2017. URL https://doi.org/10.18653/v1/P17-1123. ",
+        "bbox": [
+            173,
+            498,
+            825,
+            555
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nan Duan, Duyu Tang, Peng Chen, and Ming Zhou. Question generation for question answering. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 866–874, 2017. URL https: //aclanthology.info/papers/D17-1090/d17-1090. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            623
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris Dyer, Adhiguna Kuncoro, Miguel Ballesteros, and Noah A. Smith. Recurrent neural network grammars. In NAACL HLT 2016, The 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, San Diego California, USA, June 12-17, 2016, pp. 199–209, 2016. URL http://aclweb.org/anthology/N/ N16/N16-1024.pdf. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Abdessamad Echihabi and Daniel Marcu. A noisy-channel approach to question answering. In Proceedings of the 41st Annual Meeting of the Association for Computational Linguistics, 7- 12 July 2003, Sapporo Convention Center, Sapporo, Japan., pp. 16–23, 2003. URL http: //aclweb.org/anthology/P/P03/P03-1003.pdf. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yarin Gal and Zoubin Ghahramani. A theoretically grounded application of dropout in recurrent neural networks. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pp. 1019–1027, 2016. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            842
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yash Goyal, Tejas Khot, Douglas Summers-Stay, Dhruv Batra, and Devi Parikh. Making the V in VQA matter: Elevating the role of image understanding in visual question answering. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 6325–6334, 2017. URL https://doi.org/10.1109/CVPR.2017. 670. ",
+        "bbox": [
+            176,
+            853,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In 2016 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2016, Las Vegas, NV, USA, June 27-30, 2016, pp. 770–778, 2016. URL https://doi.org/10.1109/ CVPR.2016.90. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luheng He, Kenton Lee, Omer Levy, and Luke Zettlemoyer. Jointly predicting predicates and arguments in neural semantic role labeling. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics, ACL 2018, Melbourne, Australia, July 15-20, 2018, Volume 2: Short Papers, pp. 364–369, 2018. URL https://aclanthology.info/papers/ P18-2058/p18-2058. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Heilman and Noah A. Smith. Good question! statistical ranking for question generation. In Human Language Technologies: The 2010 Annual Conference of the North American Chapter of the Association for Computational Linguistics, HLT ’10, pp. 609–617. Association for Computational Linguistics, 2010. ISBN 1-932432-65-5. URL http://dl.acm.org/citation. cfm?id=1857999.1858085. ",
+        "bbox": [
+            173,
+            247,
+            826,
+            316
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minghao Hu, Yuxing Peng, Zhen Huang, Xipeng Qiu, Furu Wei, and Ming Zhou. Reinforced mnemonic reader for machine reading comprehension. In Proceedings of the Twenty-Seventh International Joint Conference on Artificial Intelligence, IJCAI 2018, July 13-19, 2018, Stockholm, Sweden., pp. 4099–4106, 2018. URL https://doi.org/10.24963/ijcai.2018/570. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            382
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Drew A. Hudson and Christopher D. Manning. Compositional attention networks for machine reasoning. CoRR, abs/1803.03067, 2018. URL http://arxiv.org/abs/1803.03067. ",
+        "bbox": [
+            171,
+            390,
+            823,
+            420
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 448–456, 2015. URL http://jmlr. org/proceedings/papers/v37/ioffe15.html. ",
+        "bbox": [
+            173,
+            428,
+            825,
+            484
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robin Jia and Percy Liang. Adversarial examples for evaluating reading comprehension systems. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, EMNLP 2017, Copenhagen, Denmark, September 9-11, 2017, pp. 2021–2031, 2017. URL https://aclanthology.info/papers/D17-1215/d17-1215. ",
+        "bbox": [
+            173,
+            492,
+            825,
+            549
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Bharath Hariharan, Laurens van der Maaten, Li Fei-Fei, C. Lawrence Zitnick, and Ross B. Girshick. CLEVR: A diagnostic dataset for compositional language and elementary visual reasoning. In 2017 IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2017, Honolulu, HI, USA, July 21-26, 2017, pp. 1988–1997, 2017. URL https://doi.org/ 10.1109/CVPR.2017.215. ",
+        "bbox": [
+            173,
+            556,
+            825,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mandar Joshi, Eunsol Choi, Daniel S. Weld, and Luke Zettlemoyer. Triviaqa: A large scale distantly supervised challenge dataset for reading comprehension. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 1601–1611, 2017. URL https://doi.org/10. 18653/v1/P17-1147. ",
+        "bbox": [
+            173,
+            635,
+            825,
+            705
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoon Kim, Yacine Jernite, David Sontag, and Alexander M. Rush. Character-aware neural language models. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, February 12-17, 2016, Phoenix, Arizona, USA., pp. 2741–2749, 2016. URL http://www.aaai.org/ ocs/index.php/AAAI/AAAI16/paper/view/12489. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            771
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kenton Lee, Tom Kwiatkowski, Ankur P. Parikh, and Dipanjan Das. Learning recurrent span representations for extractive question answering. CoRR, abs/1611.01436, 2016. URL http: //arxiv.org/abs/1611.01436. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yikang Li, Nan Duan, Bolei Zhou, Xiao Chu, Wanli Ouyang, and Xiaogang Wang. Visual question generation as dual task of visual question answering. CoRR, abs/1709.07192, 2017. URL http: //arxiv.org/abs/1709.07192. ",
+        "bbox": [
+            173,
+            830,
+            823,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Feng Liu, Tao Xiang, Timothy M. Hospedales, Wankou Yang, and Changyin Sun. ivqa: Inverse visual question answering. CoRR, abs/1710.03370, 2017. URL http://arxiv.org/abs/ 1710.03370. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen Merity, Caiming Xiong, James Bradbury, and Richard Socher. Pointer sentinel mixture models. CoRR, abs/1609.07843, 2016. URL http://arxiv.org/abs/1609.07843. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted boltzmann machines. In Proceedings of the 27th International Conference on Machine Learning (ICML-10), June 21- 24, 2010, Haifa, Israel, pp. 807–814, 2010. URL http://www.icml2010.org/papers/ 432.pdf. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            195
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ethan Perez, Florian Strub, Harm de Vries, Vincent Dumoulin, and Aaron C. Courville. Film: Visual reasoning with a general conditioning layer. In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, New Orleans, Louisiana, USA, February 2-7, 2018, 2018. URL https://www.aaai.org/ocs/index.php/AAAI/AAAI18/paper/view/16528. ",
+        "bbox": [
+            174,
+            203,
+            825,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 2227–2237, 2018. URL https://aclanthology.info/ papers/N18-1202/n18-1202. ",
+        "bbox": [
+            173,
+            266,
+            825,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. 2018. URL http://openai-assets.s3. amazonaws.com/research-covers/language-unsupervised/language_ understanding_paper.pdf. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            415
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin Raison, Pierre-Emmanuel Mazare, Rajarshi Das, and Antoine Bordes. Weaver: Deep co- ´ encoding of questions and documents for machine reading. arXiv preprint arXiv:1804.10490, 2018. ",
+        "bbox": [
+            173,
+            421,
+            825,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Jian Zhang, Konstantin Lopyrev, and Percy Liang. Squad: 100, $0 0 0 +$ questions for machine comprehension of text. In Proceedings of the 2016 Conference on Empirical Methods in Natural Language Processing, EMNLP 2016, Austin, Texas, USA, November 1-4, 2016, pp. 2383–2392, 2016. URL http://aclweb.org/anthology/D/D16/D16-1264.pdf. ",
+        "bbox": [
+            173,
+            472,
+            825,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pranav Rajpurkar, Robin Jia, and Percy Liang. Know what you don’t know: Unanswerable questions for squad. In Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics, ACL 2018, Melbourne, Australia, July 15-20, 2018, Volume 2: Short Papers, pp. 784– 789, 2018. URL https://aclanthology.info/papers/P18-2124/p18-2124. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            593
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marc-Antoine Rondeau and Timothy J. Hazen. Systematic error analysis of the stanford question answering dataset. In Proceedings of the Workshop on Machine Reading for Question Answering@ACL 2018, Melbourne, Australia, July 19, 2018, pp. 12–20, 2018. URL https: //aclanthology.info/papers/W18-2602/w18-2602. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            656
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mrinmaya Sachan and Eric P. Xing. Self-training for jointly learning to ask and answer questions. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 629–640, 2018. URL https: //aclanthology.info/papers/N18-1058/n18-1058. ",
+        "bbox": [
+            173,
+            662,
+            825,
+            733
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Min Joon Seo, Aniruddha Kembhavi, Ali Farhadi, and Hannaneh Hajishirzi. Bidirectional attention flow for machine comprehension. CoRR, abs/1611.01603, 2016. URL http://arxiv.org/ abs/1611.01603. ",
+        "bbox": [
+            171,
+            739,
+            823,
+            782
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yelong Shen, Po-Sen Huang, Jianfeng Gao, and Weizhu Chen. Reasonet: Learning to stop reading in machine comprehension. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, Halifax, NS, Canada, August 13 - 17, 2017, pp. 1047–1055, 2017. URL http://doi.acm.org/10.1145/3097983.3098177. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            847
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 2440–2448, 2015. URL http://papers.nips.cc/paper/ 5846-end-to-end-memory-networks. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ilya Sutskever, Oriol Vinyals, and Quoc V. Le. Sequence to sequence learning with neural networks. In Advances in Neural Information Processing Systems 27: Annual Conference on Neural Information Processing Systems 2014, December 8-13 2014, Montreal, Quebec, Canada, pp. 3104–3112, 2014. URL http://papers.nips.cc/paper/ 5346-sequence-to-sequence-learning-with-neural-networks. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Charles A. Sutton and Andrew McCallum. An introduction to conditional random fields. Foundations and Trends in Machine Learning, 4(4):267–373, 2012. URL https://doi.org/10. 1561/2200000013. ",
+        "bbox": [
+            173,
+            184,
+            825,
+            226
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Duyu Tang, Nan Duan, Tao Qin, and Ming Zhou. Question answering and question generation as dual tasks. CoRR, abs/1706.02027, 2017. URL http://arxiv.org/abs/1706.02027. ",
+        "bbox": [
+            173,
+            234,
+            823,
+            265
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Duyu Tang, Nan Duan, Zhao Yan, Zhirui Zhang, Yibo Sun, Shujie Liu, Yuanhua Lv, and Ming Zhou. Learning to collaborate for question answering and asking. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, NAACL-HLT 2018, New Orleans, Louisiana, USA, June 1-6, 2018, Volume 1 (Long Papers), pp. 1564–1574, 2018. URL https://aclanthology.info/papers/ N18-1141/n18-1141. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            358
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems 30: Annual Conference on Neural Information Processing Systems 2017, 4-9 December 2017, Long Beach, CA, USA, pp. 6000–6010, 2017. URL http: //papers.nips.cc/paper/7181-attention-is-all-you-need. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            438
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 2692–2700, 2015. URL http://papers.nips.cc/paper/5866-pointer-networks. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            505
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Wenhui Wang, Nan Yang, Furu Wei, Baobao Chang, and Ming Zhou. Gated self-matching networks for reading comprehension and question answering. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, ACL 2017, Vancouver, Canada, July 30 - August 4, Volume 1: Long Papers, pp. 189–198, 2017. URL https://doi.org/10.18653/v1/ P17-1018. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            583
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhiguo Wang, Haitao Mi, Wael Hamza, and Radu Florian. Multi-perspective context matching for machine comprehension. CoRR, abs/1612.04211, 2016. URL http://arxiv.org/abs/ 1612.04211. ",
+        "bbox": [
+            171,
+            593,
+            825,
+            636
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dirk Weissenborn, Georg Wiese, and Laura Seiffe. Making neural QA as simple as possible but not simpler. In Proceedings of the 21st Conference on Computational Natural Language Learning (CoNLL 2017), Vancouver, Canada, August 3-4, 2017, pp. 271–280, 2017. URL https:// doi.org/10.18653/v1/K17-1028. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            702
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Caiming Xiong, Victor Zhong, and Richard Socher. $\\mathrm { D C N + }$ : mixed objective and deep residual coattention for question answering. CoRR, abs/1711.00106, 2017. URL http://arxiv. org/abs/1711.00106. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            753
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Adams Wei Yu, David Dohan, Minh-Thang Luong, Rui Zhao, Kai Chen, Mohammad Norouzi, and Quoc V. Le. Qanet: Combining local convolution with global self-attention for reading comprehension. CoRR, abs/1804.09541, 2018. URL http://arxiv.org/abs/1804.09541. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            806
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lei Yu, Phil Blunsom, Chris Dyer, Edward Grefenstette, and Tomas Kocisk ´ y. The neural noisy ´ channel. CoRR, abs/1611.02554, 2016. URL http://arxiv.org/abs/1611.02554. ",
+        "bbox": [
+            169,
+            815,
+            823,
+            844
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xingdi Yuan, Tong Wang, C¸ aglar Gulc¸ehre, Alessandro Sordoni, Philip Bachman, Saizheng Zhang, ¨ Sandeep Subramanian, and Adam Trischler. Machine comprehension by text-to-text neural question generation. In Proceedings of the 2nd Workshop on Representation Learning for NLP, Rep4NLP@ACL 2017, Vancouver, Canada, August 3, 2017, pp. 15–25, 2017. URL https: //aclanthology.info/papers/W17-2603/w17-2603. ",
+        "bbox": [
+            174,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Yuandong Tian, Sainbayar Sukhbaatar, Arthur Szlam, and Rob Fergus. Simple baseline for visual question answering. CoRR, abs/1512.02167, 2015. URL http://arxiv.org/ abs/1512.02167. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            172,
+            375,
+            189
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 SQUAD MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            203,
+            331,
+            218
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Pre-processing Questions and answers were tokenized with a simple rule-based tokenizer. We ignored training examples whose answers did not correspond to words in our tokenization. We also found it helpful to append the article title as an additional sentence at the end of paragraphs, as frequently question words make use of an entity mentioned in the title that is not in the paragraph. Finally, we replace question words with similar words from the context (based on sharing word stems or low edit distance), which makes it easier for the model to explain rare words and typographical errors in questions by using the pointer mechanism. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            327
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Architecture The encoder contains 2 answer-independent LSTM layers and 3 answer-dependent LSTM layers, all of hidden size 128. The decoder contains 9 blocks, all with hidden size $d = 2 5 6$ . We apply dropout $( p = 0 . 5 5 )$ to contextualised word representations, after encoder LSTM layers and after each decoder block (before residual connects). We also used word level dropout after contextualised embeddings for each encoder $( p = 0 . 1 )$ ) and decoder word $( p = 0 . 2 5 )$ ), and disallow use of the pointer mechanism with $p = 0 . 2 5$ . All dropout masks are fixed across time-steps (Gal & Ghahramani, 2016). ",
+        "bbox": [
+            174,
+            343,
+            825,
+            440
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Optimisation We train generatively with batches of 10 documents, using a cosine learning rate schedule with a period of 1 epoch, warming up over the first 5 epochs to a maximum learning rate of $1 0 ^ { - 4 }$ . During fine-tuning, we freeze the answer-independent context encoding and $p ( a | c )$ model, which both reduces memory requirements and makes learning more stable. If the correct answer is not in the beam, we make no update. Fine tuning uses stochastic gradient descent with single question batches, learning rate $5 * \\bar { 1 } 0 ^ { - 5 }$ , and momentum 0.97. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            540
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 CLEVR MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            333,
+            570
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Architecture All hidden layers in the encoder have size 128. We use 3 blocks of convolution, batch normalisation, and ReLU activations. The first block uses a 1x1 convolution to project the pre-trained features to size 128, and the other blocks use 3x3 convolutions. We apply dropout with rate 0.1 to the pre-trained image features. In the decoder we use a dimension $d = 2 5 6$ with 6 decoder blocks, with dropout $\\cdot p = 0 . 2 5 ,$ ) before residual connections. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            651
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Optimisation We optimise with stochastic gradient descent with momentum 0.9, with an initial learning rate of 0.025 which is decayed by a factor of 5 when there is no improvement for 10 epochs. For generative training we use batch size 1024. For fine tuning, we use initial learning rate 0.001 and batch size 32. ",
+        "bbox": [
+            174,
+            667,
+            823,
+            723
+        ],
+        "page_idx": 13
+    }
+]

parse/train/H1lS8oA5YQ/H1lS8oA5YQ.md

@@ -0,0 +1,393 @@
+# FEATURE ATTRIBUTION AS FEATURE SELECTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Feature attribution methods identify “relevant” features as an explanation of a complex machine learning model. Several feature attribution methods have been proposed; however, only a few studies have attempted to define the “relevance” of each feature mathematically. In this study, we formalize the feature attribution problem as a feature selection problem. In our proposed formalization, there arise two possible definitions of relevance. We name the feature attribution problems based on these two relevances as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS). We show that several existing feature attribution methods can be interpreted as approximation algorithms for EFS and IFS. Moreover, through exhaustive experiments, we show that IFS is better suited as the formalization for the feature attribution problem than EFS.
+
+# 1 INTRODUCTION
+
+Feature attribution methods (Simonyan et al., 2013; Springenberg et al., 2014), or saliency maps, are one of the most popular approaches for explaining the decisions of complex machine learning models such as deep neural networks. In feature attribution, for each given instance, the feature attribution methods score how strongly each feature is relevant to the model’s decision. An informal definition of the feature attribution problem can be described as follows. We note that this definition is incomplete because the “relevance” of each feature is not defined.
+
+Feature Attribution Problem Given the model $f$ and the target input $x \in \mathbb { R } ^ { d }$ to be explained, score $s _ { i } \in \mathbb { R }$ to each feature $x _ { i }$ $( i = 1 , 2 , \ldots , d )$ so that $s _ { i } \geq s _ { j }$ if the feature $x _ { i }$ is more relevant to the model’s decision than the feature $x _ { j }$ .
+
+With feature attribution methods, the relevant features can be obtained as explanations why the models made certain decisions. For example, in image recognition, feature attribution methods highlight pixels which the models have focused on, by scoring the relevance of each pixel (Simonyan et al., 2013; Springenberg et al., 2014; Bach et al., 2015; Smilkov et al., 2017), and in text classification, they detect the set of words or sentences relevant to the model’s decision by scoring each word or sentence (Ding et al., 2017; Chen et al., 2018).
+
+The major approaches for feature attribution are based on gradient and its modifications (Simonyan et al., 2013; Springenberg et al., 2014; Bach et al., 2015; Smilkov et al., 2017; Shrikumar et al., 2017) and feature occlusions (Zeiler & Fergus, 2014; Zhou et al., 2014).
+
+Most of the studies proposed computational algorithms without defining the “relevance” mathematically (except for some axiomatic approaches (Sundararajan et al., 2017; Lundberg & Lee, 2017)). This means that it is not clear what these algorithm outputs, and we cannot compare these outputs rigorously. To clarify the situation and to establish solid feature attribution methods, we pose the following research questions: (Q1) how can we define relevance? (Q2) is there a general framework for the relevance that induces existing feature attribution methods? and (Q3) what is an appropriate definition of relevance?
+
+In this study, we formalize the feature attribution problem as feature selection problem, and thereby answer questions (Q1)–(Q3). In our proposed formalization, there arise two possible definitions of relevance. We name the feature attribution problems based on these two relevances as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS).
+
+Below, we summarize our contributions.
+
+![](images/c0fa6b6e8aa8cfcd9d6cca7958837340fe672352ebe8995d2ec037d82fc1c8a8.jpg)  
+Figure 1: Reorganizing feature attribution methods as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS). See the references for the details of each method: Grad (Simonyan et al., 2013), Grad $. \times$ Input (Shrikumar et al., 2016), IntGrad (Sundararajan et al., 2017), SmoothGrad (Smilkov et al., 2017; Hooker et al., 2018), LIME (Ribeiro et al., 2016), SHAP (Lundberg & Lee, 2017), GuidedBP (Springenberg et al., 2014), ExciteBP (Zhang et al., 2016), LRP (Bach et al., 2015), DeepTaylor (Montavon et al., 2017), DeepLIFT (Shrikumar et al., 2017), Occlusion (Zeiler & Fergus, 2014), Detector (Zhou et al., 2014), Anchor (Ribeiro et al., 2018), Meaningful Perturbation (Fong & Vedaldi, 2017), and PertMap (Hara et al., 2018; Ikeno & Hara, 2018)
+
+Answer to Q1: We introduce two formalizations, namely EFS and IFS (Section 2). We formalize the feature attribution problem as feature selection problem, because the goal of feature attribution is to identify the relevant features to the model’s decision. Here, we point out that there are two possible approaches for characterizing the relevance of the features. In the first approach, EFS, we exclude some features from the model, and if the model’s decision changes by the exclusion, we infer the excluded features are relevant since they have certain impacts to the decision. In the second approach, IFS, we include some features to the model, and if the model’s decision remains unchanged after the inclusion, we infer the included features are relevant since they are essential to the decision.
+
+Answer to Q2: The existing methods are based on the relevances of EFS and IFS (Section 3). We show that several existing feature attribution methods can be interpreted as approximation algorithms for EFS or IFS, as summarized in Figure 1. For example, the gradient-based methods are one-step gradient descent for the continuous relaxation of EFS and IFS.
+
+Answer to Q3: The relevance based on IFS is better suited for the feature attribution problem (Section 5). We observe that IFS is better suited as the formalization for the feature attribution problem than EFS. Through exhaustive experiments, we found two crucial properties of EFS. First, the optimal solution to EFS is very similar to adversarial example (Szegedy et al., 2013). As adversarial examples generally provide seemingly meaningless attributions, they are not appropriate for the purpose of explanation. Second, we empirically observe that even a random attribution can perform comparably well with some of the existing feature attribution methods under the evaluation based on EFS. This observation indicates that there are only subtle differences between good attributions and random attributions under EFS. In contrast, unlike EFS, IFS has no trivial drawbacks, and we argue that IFS would be an appropriate formalization for the feature attribution problem.
+
+In this paper, we use the following notation, and consider the problem setting as follows.
+
+Notation For any positive integer $d , \ [ d ]$ denotes the set $[ d ] ~ = ~ \{ 1 , 2 , \ldots , d \}$ . We denote $d$ - dimensional vectors with all zeros as $0 _ { d }$ . For a proposition $a$ , $\mathbb { I } ( a )$ denotes the indicator of $a$ , i.e., $\mathbb { I } ( a ) = 1$ if $a$ is true, and $\mathbb { I } ( a ) = 0$ if $a$ is false.
+
+Settings In this paper, we consider the classification model $f$ for $C$ categories that return an output $y \in \breve { \mathbb { R } } ^ { C }$ for a given data $\boldsymbol { x } ~ \in ~ \mathbb { R } ^ { d }$ , i.e., $y \ = \ f ( x )$ . The classification result is determined by $c = \operatorname { a r g m a x } _ { j } y _ { j }$ where $y _ { j } = f _ { j } ( x )$ is the $j$ -th element of the output. We assume that the model $f$ is differentiable with respect to the input $x$ : the target models therefore include linear models, kernel models with differentiable kernels, and deep neural networks. We assume that the model $f$ and the target input $x$ to be explained are given and fixed.
+
+# 2 FEATURE ATTRIBUTION AS FEATURE SELECTION
+
+(Q1) How can we define the relevance?
+
+As an answer to this question, we formalize the feature attribution problem as feature selection problem, and introduce two definitions of relevance.
+
+Before formalizing the problem, we introduce the idea of data corruption (Samek et al., 2017; Fong & Vedaldi, 2017), which plays an important role in this study. Here, we consider corrupting the input data $x$ by overlaying partial features with a noise $r \in \mathbb { R } ^ { d }$ , as follows.
+
+Definition 2.1 (Data Corruption). For a vector $x \in \mathbb { R } ^ { d }$ , the corruption of $x$ with the set $S \subseteq [ d ]$ and the vector $r \in  { \mathbb { R } ^ { d } }$ is given by $x _ { S , r }$ , which is defined below.
+
+$$
+( x _ { S , r } ) _ { i } = \left\{ { r _ { i } \mathrm { \quad ~ i f ~ } i \in S } , \right.
+$$
+
+We refer to the set $S$ as corrupted features.
+
+Here, we assume that the noise $r$ follows a distribution $p ( r )$ . In Section 5, we introduce two types of noises $r$ for the images; we overlay the image to be explained with random noises and random real images.
+
+We now consider the problem formalization. Recall that the objective of feature attribution is to provide high scores to relevant features to the model’s decision and low scores to irrelevant features. Our idea is to define the relevance and irrelevance using data corruption. Specifically, in this study, we consider two types of feature selection problems based on data corruption. We name those two problems as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS).
+
+# 2.1 EXCLUSIVE FEATURE SELECTION (EFS)
+
+One way of measuring the relevance of features is to corrupt some of the features by overlaying with uninformative values and observe how the model’s decision changes. If the corruption of certain features leads to a decision change, such features can be considered as “relevant”. We note that corrupting many features easily leads to a decision change. Therefore, our focus is mainly on a small number of crucial features that can change the decision. We formalize this idea as Exclusive Feature Selection (EFS). In EFS, we aim at changing the decision of the model $f$ to a class different from $c$ by corrupting only a small number of features. See Figure 2 for the idea of EFS. The idea of EFS was originally proposed for measuring the performance of feature attribution methods (Samek et al., 2017). Here, we define EFS as follows.
+
+Definition 2.2 (Exclusive Feature Selection (EFS)). Find the feature corruption $S \subseteq [ d ]$ such that (i) the number of corrupted features $| S |$ is small, and (ii) the corrupted data $x _ { S , r }$ has small intensity at class $c$ , i.e. $f _ { c } ( x _ { S , r } )$ is small, so that the corrupted data is classified into a different class.
+
+$$
+\begin{array} { r } { S _ { \mathrm { E F S } } : = \mathrm { a r g m i n } _ { S \subseteq [ d ] } | S | + \lambda \mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ] , } \end{array}
+$$
+
+where $\mathbb { E } _ { r }$ denotes the expectation over the noise $r$ , and $\lambda > 0$ is a weight parameter determined by the user.
+
+In this definition, we consider the expected intensity $\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ]$ over the noise $r$ so to avoid the corruption to overfit a specific realization of the noise $r$ .
+
+By using the solution of EFS, we can define relevance as a binary score as follows. That is, in EFS, the relevant features are the ones when excluded from the data lead to the model’s decision change.
+
+Definition 2.3 (EFS-Relevance). The relevance of each feature $x _ { i }$ is defined by $s _ { i } : = \mathbb { I } ( i \in S _ { \mathrm { E F S } } )$
+
+![](images/c1abffe631b4af9e961d14fb33f1ae5d1263a08639de15355d9f2b915d6321f6.jpg)  
+Figure 2: The idea of EFS: Within the trade-off between intensity $\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ]$ and the number of corrupted features $| S |$ , find $S$ that minimizes the intensity and its size. The red pixels indicate the corrupted features $S$ . The corrupted features $S$ in the second image is optimal in this curve.
+
+![](images/acb2c47a5e2b29a0481ba61d33e14871d810f97cb4f67d1088a918362c2639a4.jpg)  
+Figure 3: The idea of IFS: Within the trade-off between intensity $\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ]$ and the number of corrupted features $| S |$ , find $S$ that maximizes the intensity and its size. The red pixels indicate the corrupted features $S$ . The corrupted features $S$ in the fourth image is optimal in this curve.
+
+# 2.2 INCLUSIVE FEATURE SELECTION (IFS)
+
+Data corruption can be used for measuring the relevance of features in a way different from that of EFS. If the corruption of certain features does not change the model’s decision, such features can be considered as “irrelevant”. We note that zero corruption trivially keeps the decision unchanged. Therefore, our focus is mainly on a small number of crucial features that have to be kept to maintain the decision. Therefore, in Inclusive Feature Selection, we aim at maintaining the decision of the model $f$ in the class $c$ while corrupting as many features as possible. See Figure 3 for the idea of IFS. Here, we formally define IFS as follows.
+
+Definition 2.4 (Inclusive Feature Selection (IFS)). Find the feature corruption $S \subseteq [ d ]$ such that (i) the number of corrupted features $| S |$ is large, and (ii) the corrupted data $x _ { S , r }$ has high intensity at class $c$ , i.e. $f _ { c } ( x _ { S , r } )$ is large, so that the corrupted data is classified to the class $c$ .
+
+$$
+\begin{array} { r } { S _ { \mathrm { I F S } } : = \mathrm { a r g m a x } _ { S \subseteq [ d ] } | S | + \lambda \mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ] . } \end{array}
+$$
+
+By using the solution of IFS, we can define relevance as follows. In IFS, the relevant features are the ones that when included in the data keep the model’s decision unchanged.
+
+Definition 2.5 (IFS-Relevance). The relevance of each feature $x _ { i }$ is defined by $s _ { i } : = \mathbb { I } ( i \notin S _ { \mathrm { I F S } } )$ .
+
+# 3 FEATURE ATTRIBUTION METHODS AS EFS AND IFS
+
+(Q2) Is there a general framework for the relevance that induces existing feature attribution methods?
+
+As an answer to this question, we show that the existing feature attribution methods can be interpreted as approximation algorithms for EFS or IFS. Thus, the relevances considered in the existing methods are approximated versions of EFS-Relevance and IFS-Relevance. To show this, we classify the existing methods into three types of approaches for solving EFS and IFS: occlusion-based, optimization-based, and gradient-based. See Figure 1 for the overview.
+
+# 3.1 OCCLUSION-BASED APPROACHES
+
+Occlusion-based feature attribution methods (Zeiler & Fergus, 2014; Zhou et al., 2014; Ribeiro et al., 2018) measure the relevance by partially masking features. In those methods, the features are masked by sliding windows or patches, and the change of the output $f _ { c }$ is computed. This can be interpreted as an approximation algorithm for solving the problems (2.2) and (2.3). Instead of searching over exponentially large solution candidates $S \subseteq [ d ]$ , those methods search only over the subset of the solution candidates. For example, one prepares a set of feature subsets $\{ S _ { m } : S _ { m } \subseteq$ $[ d ] \} _ { m = 1 } ^ { M }$ , and searches for an optimal combination of the subsets by using a greedy algorithm (Zhou14) or by a bandit algorithm (Ribeiro et al., 2018).
+
+# 3.2 OPTIMIZATION-BASED APPROACHES
+
+In order to introduce the optimization-based feature attribution methods, we consider the continuous relaxation of EFS and IFS, as follows.
+
+Definition 3.1 (Continuous Corruption). For a vector $x \in \mathbb { R } ^ { d }$ , the continuous corruption of $x$ with the vector $w \in [ 0 , 1 ] ^ { d }$ and the vector $r \in \mathbb { R } ^ { d }$ is given by $\bar { x } _ { w , r }$ , which is defined below.
+
+$$
+( \bar { x } _ { w , r } ) _ { i } = ( 1 - w _ { i } ) x _ { i } + w _ { i } r _ { i } .
+$$
+
+Here, the vector $w$ can be interpreted as the continuous relaxation of the indicator of the set $S$ .
+
+Definition 3.2 (Continuous EFS (C-EFS)). Find the vector $w \in [ 0 , 1 ] ^ { d }$ such that (i) the amount of corruption $\textstyle \sum _ { i = 1 } ^ { d } w _ { i }$ is small, and (ii) the corrupted data $\bar { x } _ { w , r }$ has small intensity at class $c$ :
+
+$$
+\begin{array} { r } { w _ { \mathrm { E F S } } : = \operatorname * { a r g m i n } _ { w \in [ 0 , 1 ] ^ { d } } \sum _ { i = 1 } ^ { d } w _ { i } + \lambda \mathbb { E } _ { r } [ f _ { c } ( \bar { x } _ { w , r } ) ] . } \end{array}
+$$
+
+Definition 3.3 (Continuous IFS (C-IFS)). Find the vector $w \in [ 0 , 1 ] ^ { d }$ such that (i) the amount of corruption $\textstyle \sum _ { i = 1 } ^ { d } w _ { i }$ is large, and (ii) the corrupted data $\bar { x } _ { w , r }$ has large intensity at class $c$ :
+
+$$
+\begin{array} { r } { w _ { \mathrm { I F S } } : = \operatorname * { a r g m a x } _ { w \in [ 0 , 1 ] ^ { d } } \sum _ { i = 1 } ^ { d } w _ { i } + \lambda \mathbb { E } _ { r } [ f _ { c } ( \bar { x } _ { w , r } ) ] . } \end{array}
+$$
+
+For C-EFS and C-IFS, the feature attribution scores can be defined as $s _ { i } = w _ { \mathrm { E F S } , i }$ and $s _ { i } = 1 -$ $w _ { \mathrm { I F S } , i }$ , respectively. We note that, for a differentiable model $f$ , the objective functions of C-EFS (3.2) and C-IFS (3.3) are differentiable. Therefore, these problems can be solved using gradientbased optimization methods such as SGD and Adam (Kingma & Ba, 2014).
+
+Fong & Vedaldi (2017) first introduced the formulation of C-EFS, and they proposed Meaningful Perturbation by adding a smoothness penalty term to C-EFS. PertMap (Hara et al., 2018; Ikeno & Hara, 2018), another optimization-based method, can be interpreted as a variant of C-IFS. PertMap is equivalent to C-IFS with the term $\mathbb { E } _ { r } [ f _ { c } ( \bar { x } _ { w , r } ) ]$ replaced with the hinge penalty term $\begin{array} { r } { \sum _ { j \neq c } \bar { \mathbb { E } } _ { r } [ \operatorname* { m i n } ( 0 , f _ { c } ( \bar { x } _ { w , r } ) - f _ { j } ( \bar { x } _ { w , r } ) ) ] } \end{array}$ that penalizes $w$ only when the corrupted data is classified into other classes. See Appendix A for the detail.
+
+# 3.3 GRADIENT-BASED APPROACHES
+
+Many feature attribution methods are based on the gradient of the model’s output ∂fc(x) . ∂xi Here, we point out that those gradient-based feature attribution methods can be interpreted as one-step gradient descent/ascent approximations for C-EFS and C-IFS. If we consider solving the problems (3.2) and (3.3) using gradient descent/ascent with the initial $w$ set to zeros, i.e. $w = 0 _ { d }$ , then, the first step of the optimization can be expressed as $\begin{array} { r } { w _ { i }  0 \pm \eta \{ \mathbb { E } _ { r } [ \frac { \partial f _ { c } ( \bar { x } _ { w , r } ) } { \partial w _ { i } } \Big | _ { w = 0 _ { d } } ] + \lambda \} \propto } \end{array}$ $\begin{array} { r } { \frac { \partial f _ { c } ( x ) } { \partial x _ { i } } ( \mu _ { i } - x _ { i } ) + \lambda } \end{array}$ , where $\eta > 0$ is the step size and $\mu _ { i } : = \mathbb { E } _ { r } [ r _ { i } ]$ . Here, because the penalty $\lambda$ and the step size $\eta$ are common across all the features, ${ \frac { \partial f _ { c } ( x ) } { \partial x _ { i } } } ( \mu _ { i } - x _ { i } )$ is the essential term that determines the size of $w _ { i }$ . This finding naturally connects EFS/IFS and the gradient-based feature attribution methods. See Appendix $\mathbf { B }$ for the details.
+
+# 4 EFS AND IFS AS EVALUATION METRIC
+
+The ideas of EFS and IFS can be used as metrics for evaluating the performance of feature attribution methods. Suppose that the feature attribution score $s \in \mathbb { R } ^ { d }$ is given.
+
+EFS-based Metric The principle of EFS is that “crucial attribution should change the model’s decision by corrupting only a small number of relevant features”. For $q \in [ 0 , 1 ]$ , let the set of the top- $100 q \%$ relevant features be $S _ { q } : = \{ i : s _ { i } \geq t _ { q } \}$ , where $t _ { q }$ is the $1 0 0 q$ -th largest percentile in $s$ so that $| S _ { q } | = q d$ . Then, we can draw a curve showing the trade-off between the ratio of corrupted relevant features and the degree of the output change (Samek et al., 2017). For example, as the degree of the output changes, we can use the expected difference in intensity: $g _ { c } ^ { \mathrm { i n t e n s i t y } } ( \bar { S _ { q } } ) : = \mathbb { E } _ { r } [ f _ { c } ( \bar { x } ) -$ $f _ { c } ( x _ { S _ { q } , r } ) ]$ , and the probability of label mismatch: $g _ { c } ^ { \mathrm { l a b e l } } ( S _ { q } ) : = \mathbb { E } _ { r } [ \mathbb { I } ( c \neq \operatorname { a r g m a x } _ { j } f _ { j } ( x _ { S _ { q } , r } ) ) ]$ . The trade-off curve usually shows an increasing trend, and the area under the curve can be used as a measure of how quickly the output changes with an increase in the ratio of corrupted features (see Figure 4). In this paper, we refer to this area as Area Under the EFS-Curve (AUEC).
+
+IFS-based Metric The principle of IFS is that “crucial attribution should maintain the model’s output even if many irrelevant features are corrupted”. Similar to EFS, we can construct an IFSbased metric based on this principle. Let $S _ { q } : = \{ i : s _ { i } \geq t _ { q } \}$ be the top- $100 q \%$ relevant features, as defined above. We then corrupt irrelevant features other than $S _ { q }$ , i.e. $\bar { S } _ { q } : = [ d ] \setminus S _ { q }$ . We can then draw a curve showing the trade-off between the ratio of corrupted irrelevant features and the degree of the output change such as $g _ { c } ^ { \mathrm { i n t e n s i t y } } \left( \bar { S } _ { q } \right)$ and $g _ { c } ^ { \mathrm { l a b e l } } ( \bar { S } _ { q } )$ . The trade-off curve usually shows an increasing trend with an increase in the ratio of corrupted features (see Figure 4). Therefore, the area over the curve can be used as a measure of how resistant the model’s decision is against the feature corruption. In this paper, we refer to this area as Area Over the IFS-Curve (AOIC).
+
+# 5 EFS VS. IFS
+
+# (Q3) What is an appropriate definition of relevance?
+
+To answer this question, we compare EFS and IFS through exhaustive experiments. Our results indicate that EFS has several drawbacks, and we therefore argue that IFS-Relevance is better suited for the feature attribution problem.
+
+# 5.1 EXPERIMENTAL SETUP
+
+Models and Data As the target model $f$ to be explained, we adopted three pre-trained models, namely VGG16 (Simonyan & Zisserman, 2014), ResNet V2 with depth 152 (He et al., 2016), and Inception V3 (Szegedy et al., 2016), which were distributed at the Tensorflow repository1. As the target data $x$ to be explained, we selected 200 images from the validation set at ILSVRC2014 (Russakovsky et al., 2014) which were correctly classified by the three models.
+
+Feature Attribution Methods In the experiments, we adopted several feature attribution methods for comparison: Grad (Simonyan et al., 2013), Grad $\times$ Input (Shrikumar et al., 2016), GuidedBP (Springenberg et al., 2014), SmoothGrad (Smilkov et al., 2017; Hooker et al., 2018), IntGrad (Sundararajan et al., 2017), LRP (Bach et al., 2015), DeepLIFT (Shrikumar et al., 2017), Occlusion (Zeiler & Fergus, 2014), and PertMap (Hara et al., 2018; Ikeno & Hara, 2018). Grad,
+
+Grad $\times$ Input, GuidedBP, SmoothGrad, and IntGrad were implemented using saliency2 with default settings, and LRP, DeepLIFT, and Occlusion were implemented using DeepExplain3, where we set the mask size for Occlusion as $6 4 \times 6 4$ with the stride set to 16. We implemented PertMap based on the sample code4. We also adopted random attribution as the baseline where the score for each feature was generated uniformly random over $[ 0 , 1 ]$ .
+
+In addition to the existing feature attribution methods, we implemented the following EFS-based and IFS-based methods: Greedy-EFS, which solves the problem (2.2) using a greedy algorithm; GradEFS, which solves the problem (3.2) using gradient descent; Greedy-IFS, which solves the problem (2.3) using a greedy algorithm; and Grad-IFS, which solves the problem (3.3) using gradient ascent. The details of these methods can be found in Appendix C.
+
+Evaluation For evaluating AUEC and AOIC, we prepared two noise distributions $p ( r )$ . The first distribution is a uniform distribution: each $r$ is independently sampled from the uniform distribution over $[ 0 , 1 ] ^ { d }$ . The second distribution is a distribution over real images. We selected 100 images from the validation set at ILSVRC2014, with no overlap with the 200 images to be explained. Then, from those 100 images, we randomly selected an image as the noise $r$ . To compute AUEC and AOIC, we varied the percentile $q$ from zero to one, and for each $q$ , we computed the difference scores $g _ { c } ^ { \mathrm { l a b e l } } ( S _ { q } )$ and ${ \dot { g } } _ { c } ^ { \mathrm { l a b e l } } ( { \bar { S } } _ { q } )$ using empirical averages under those two noise distributions.
+
+# 5.2 RESULTS
+
+For each model, we computed the attribution scores for all 200 images using each of the 14 feature attribution methods. We then computed AUEC and AOIC under the two noise distributions.
+
+Our main result is summarized in Table 1. Table 1 shows the AUEC and AOIC for VGG16 for the 200 images under uniform noise. We moved the results for the other models and the corruption with real images to Appendix D, as those results are similar. Here, we point out that there are three important observations in the table.
+
+EFS found adversarial example. Grad-EFS attained the highest AUEC. This indicates that GradEFS is nearly optimal under the principle of EFS: Grad-EFS can change the model’s decision by corrupting only a small number of relevant features. Indeed, as shown in Figure 4, Grad-EFS has a sharp increase in the EFS-Curve 5. Specifically, it shows that Grad-EFS successfully changed the model’s decision for more than $80 \%$ of the data by corrupting only a few percent of the pixels. Similar tendencies were also observed for ResNet V2 and Inception V3 (see Appendix D).
+
+An important observation is that the heatmap of Grad-EFS is just a shot noise, as shown in Figure 5. This is because EFS is very similar to adversarial example (Szegedy et al., 2013). In adversarial example, one seeks the minimum data perturbation that changes the model’s output. In EFS (2.2), instead of the data perturbation, one searches for a small number of corrupted features that reduces the class intensity. Similarly, C-EFS (3.2) searches for a continuous corruption with the minimum $\ell _ { 1 }$ norm.
+
+Random attribution performed comparably well with existing methods. The random attribution attained AUEC similar to that of methods such as Grad $\times$ Input, IntGrad, LRP, and Occlusion, especially for VGG16. Indeed, as shown in Figure 4, the EFS-Curve of random attribution is close to those methods. It is a bit surprising to observe that we can attain a good trade-off in EFS just by randomly scoring each feature without looking at the images. This observation indicates that there are only subtle differences between good attributions and random attributions under EFS, especially for VGG16.
+
+Grad-IFS significantly outperformed the other methods. On AOIC, Grad-IFS significantly outperformed the other methods, and PertMap attained the second best result. As shown in Figure 4, Grad-IFS is very resistant against the corruption of irrelevant features. Indeed, even if $80 \%$ of the pixels are corrupted, the model’s decision is kept unchanged for more than $80 \%$ of the images. This means that Grad-IFS is capable of identifying irrelevant features better than any other methods. Another interesting point that can be seen in Figure 4 is that, the IFS-Curves vary significantly across different methods. More importantly, unlike EFS, the IFS-Curve can distinguish random attributions and other attributions well.
+
+Table 1: Average AUEC and AOIC under the uniform noise. The top-three scores are highlighted as ${ 1 } \mathrm { s t } ^ { * }$ , $2 \mathrm { n d } ^ { \ast \ast }$ , and $3 \mathrm { r d } ^ { * * * }$ .   
+
+<table><tr><td colspan="2">VGG16</td></tr><tr><td></td><td>AUEC AOIC 0.366</td></tr><tr><td>Greedy-EFS</td><td>0.844 0.946*</td></tr><tr><td>Grad-EFS</td><td>0.195</td></tr><tr><td>Greedy-IFS</td><td>0.746 0.622***</td></tr><tr><td>Grad-IFS</td><td>0.873 0.876*</td></tr><tr><td>Grad</td><td>0.867 0.341</td></tr><tr><td>Grad×Input</td><td>0.823 0.318</td></tr><tr><td>SmoothGrad</td><td>0.882 0.593</td></tr><tr><td>GuidedBP</td><td>0.918** 0.455</td></tr><tr><td>IntGrad</td><td>0.837 0.346</td></tr><tr><td>LRP</td><td>0.823 0.318</td></tr><tr><td>DeepLIFT</td><td>0.862 0.435</td></tr><tr><td>Occlusion</td><td>0.811 0.559</td></tr><tr><td>PertMap</td><td>0.886*** 0.780**</td></tr><tr><td>Random</td><td>0.839 0.160</td></tr></table>
+
+![](images/9c67eb5a490e7f726ebac40720720b6c0c1e23f12434bacb94afaaaa89859e07.jpg)  
+Figure 4: Average EFS-Curve and IFS-Curve.
+
+![](images/98ee7dd402f94319a422b6ee772a5dcad6000134361a86730d979af8ef291839.jpg)  
+Figure 5: Attributions on VGG16: The red colored pixels are found to be strongly relevant with each method.
+
+Figure 5 shows the examples of the attributions obtained by each method. It is important to note that the top-three AOIC methods, namely Grad-IFS, PertMap, and SmoothGrad, have highlighted only the dog face. The high AOICs on these methods indicate that the model has made the decision based on the dog face. In contrast, the other methods tend to generate noisy attributions over the entire body of the dog, which are false explanations from the perspective of IFS because their AOICs are far smaller than that of Grad-IFS: the noisy attributions failed to capture essential pixels in the image.
+
+# 6 CONCLUSION
+
+In this study, we formalized the feature attribution problem as two types of feature selection problems, which we named as EFS and IFS. Based on EFS and IFS, we clarified that the existing feature attribution methods can be interpreted as approximation algorithms for EFS and IFS. Then, through exhaustive experiments, we clarified that IFS is better suited as the formalization for the feature attribution problem; we observed that EFS has several unfavorable properties and concluded that EFS is not an appropriate formalization.
+
+# REFERENCES
+
+Sebastian Bach, Alexander Binder, Gregoire Montavon, Frederick Klauschen, Klaus-Robert M ´ uller, ¨ and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS ONE, 10(7):e0130140, 2015.
+
+Jianbo Chen, Le Song, Martin Wainwright, and Michael Jordan. Learning to explain: An information-theoretic perspective on model interpretation. In Proceedings of the 35th International Conference on Machine Learning, pp. 882–891, 2018.
+
+Yanzhuo Ding, Yang Liu, Huanbo Luan, and Maosong Sun. Visualizing and understanding neural machine translation. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, pp. 1150–1159, 2017.
+
+Ruth C Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. In Proceeding of the IEEE International Conference on Computer Vision, pp. 3449 – 3457, 2017.
+
+Satoshi Hara, Kouichi Ikeno, Tasuku Soma, and Takanori Maehara. Maximally invariant data perturbation as explanation. arXiv:1806.07004, 2018.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016.
+
+Sara Hooker, Dumitru Erhan, Pieter-Jan Kindermans, and Been Kim. Evaluating feature importance estimates. arXiv:1806.10758, 2018.
+
+Kouichi Ikeno and Satoshi Hara. Maximizing invariant data perturbation with stochastic optimization. arXiv:1807.05077, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014.
+
+Scott M Lundberg and Su-In Lee. A unified approach to interpreting model predictions. In Proceedings of Advances in Neural Information Processing Systems, pp. 4765–4774, 2017.
+
+Gregoire Montavon, Sebastian Lapuschkin, Alexander Binder, Wojciech Samek, and Klaus-Robert ´ Muller. Explaining nonlinear classification decisions with deep taylor decomposition. ¨ Pattern Recognition, 65:211–222, 2017.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Why should i trust you?: Explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 1135–1144. ACM, 2016.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Anchors: High-precision model-agnostic explanations. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence, pp. 1527– 1535, 2018.
+
+Olga Russakovsky, Sanjeev Satheesh, Jia Deng, Sean Ma, Hao Su, Zhiheng Huang, Jonathan Krause, Andrej Karpathy, Alexander C Berg, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. Technical report, 2014.
+
+Wojciech Samek, Alexander Binder, Gregoire Montavon, Sebastian Lapuschkin, and Klaus-Robert ´ Muller. Evaluating the visualization of what a deep neural network has learned. ¨ IEEE transactions on neural networks and learning systems, 28(11):2660–2673, 2017.
+
+Avanti Shrikumar, Peyton Greenside, Anna Shcherbina, and Anshul Kundaje. Not just a black box: Learning important features through propagating activation differences. arXiv:1605.1713, 2016.
+
+Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In Proceedings of International Conference on Machine Learning, pp. 3145–3153, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv:1409.1556, 2014.
+
+Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv:1312.6034, 2013.   
+Daniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, and Martin Wattenberg. Smoothgrad: ´ removing noise by adding noise. arXiv:1706.03825, 2017.   
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv:1412.6806, 2014.   
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. arXiv:1703.01365, 2017.   
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv:1312.6199, 2013.   
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.   
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In Proceedings of European Conference on Computer Vision, pp. 818–833. Springer, 2014.   
+Jianming Zhang, Zhe Lin, Jonathan Brandt, Xiaohui Shen, and Stan Sclaroff. Top-down neural attention by excitation backprop. In Proceedings of European Conference on Computer Vision, pp. 543–559. Springer, 2016.   
+Bolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. arXiv:1412.6856, 2014.
+
+# SUPPLEMENTARY MATERIAL FOR “FEATURE ATTRIBUTION AS FEATURE SELECTION”
+
+Preliminaries We define the data-dependent noise by $r _ { x }$ as follows:
+
+$$
+r _ { x } : = x + u ,
+$$
+
+where we assume that the perturbation $u$ follows a distribution $p ( u )$ with $\mathbb { E } _ { u } [ u ] = 0$ . The continuous corruption with the noise $r _ { x }$ is then expressed as
+
+$$
+( \bar { x } _ { w , r _ { x } } ) _ { i } = ( 1 - w _ { i } ) x _ { i } + w _ { i } r _ { x , i } = x _ { i } + w _ { i } u _ { i } .
+$$
+
+That is, the continuous corruption $\hat { x } _ { w , r _ { x } }$ is centered at the data $x$ . Moreover, $\hat { x } _ { w , r _ { x } }$ distributes around $x$ with the magnitude $w$ . The data-dependent noise and this continuous corruption plays an important role when interpreting some of the existing feature attribution methods as EFS and IFS.
+
+# A OPTIMIZATION-BASED FEATURE ATTRIBUTION METHODS AS EFS/IFS
+
+Meaningful Perturbation (Fong & Vedaldi, 2017) is a variant of C-EFS defined below:
+
+$$
+\operatorname* { m i n } _ { w \in [ 0 , 1 ] ^ { d } } \sum _ { i = 1 } ^ { d } w _ { i } + \lambda f _ { c } ( \bar { x } _ { w , r } ) + \phi _ { \mathrm { s m o o t h } } ( w ) .
+$$
+
+The differences from C-EFS (3.2) are (i) it uses a fixed noise $r$ instead of the expectation, and (ii) the additional penalty term $\phi _ { \mathrm { s m o o t h } } ( w )$ is added so that $w$ to be smooth. Here, the smoothness penalty is essential for Meaningful Perturbation. Fong $\&$ Vedaldi (2017) have reported that the solution to the problem (A.1) without the smoothness penalty tends to be seemingly meaningless attributions. This is because C-EFS is very similar to the $\ell _ { 1 }$ penalized adversarial example, as we have discussed in Section 5. Therefore, we need to design an appropriate penalty term $\phi _ { \mathrm { s m o o t h } }$ to obtain reasonable attributions using Meaningful Perturbation.
+
+PertMap (Hara et al., 2018; Ikeno & Hara, 2018) can be interpreted as a variant of C-IFS. PertMap finds irrelevant features by maximizing the data perturbation. Let $\hat { x } _ { w , r _ { x } }$ be the continuous corruption of the data $x$ with a data-dependent noise $r _ { x }$ , where the parameter $w$ determine the magnitude of the data perturbation. In PertMap, one seeks for the maximum data perturbation that maintains the classification result unchanged from the original class $c$ . The optimization problem of $w$ is defined as follows (Ikeno & Hara, 2018):
+
+$$
+\operatorname* { m a x } _ { w \in [ 0 , 1 ] ^ { d } } \sum _ { i = 1 } ^ { d } w _ { i } + \lambda \sum _ { j \neq c } \mathbb { E } _ { r } [ \operatorname* { m i n } ( 0 , f _ { c } ( \bar { x } _ { w , r } ) - f _ { j } ( \bar { x } _ { w , r } ) ) ] .
+$$
+
+This problem is equivalent to C-EFS except for the term $\mathbb { E } _ { r } [ f _ { c } ( \bar { x } _ { w , r } ) ]$ replaced with the hinge penalty term $\begin{array} { r } { \sum _ { j \neq c } \tilde { \mathbb { E } } _ { r } [ \operatorname* { m i n } ( 0 , f _ { c } ( \bar { x } _ { w , r } ) - f _ { j } ( \bar { x } _ { w , r } ) ) ] } \end{array}$ that penalizes $w$ only when the corrupted data is classified into other classes.
+
+# B GRADIENT-BASED FEATURE ATTRIBUTION METHODS AS EFS/IFS
+
+Many feature attribution methods are based on the gradient of the model’s output ∂fc(x) . Here, we show that those gradient-based feature attribution methods can be interpreted as one-step gradient descent/ascent approximations to C-EFS and C-IFS. If we consider solving the problems (3.2) and (3.3) using gradient descent/ascent with the initial $w$ set to zeros, i.e. $w = 0 _ { d }$ , then, the first step of the optimization can be expressed as
+
+$$
+w _ { i }  0 \pm \eta \{ \mathbb { E } _ { r } [  \frac { \partial f _ { c } ( \bar { x } _ { w , r } ) } { \partial w _ { i } } | _ { w = 0 _ { d } } ] + \lambda \} \propto \frac { \partial f _ { c } ( \boldsymbol { x } ) } { \partial x _ { i } } ( \mu _ { i } - x _ { i } ) + \lambda ,
+$$
+
+where $\eta > 0$ is the step size and $\mu _ { i } : = \mathbb { E } _ { r } [ r _ { i } ]$ . Here, because the penalty $\lambda$ and the step size $\eta$ are common across all the features, $\frac { \partial f _ { c } ( x ) } { \partial x _ { i } } ( \mu _ { i } - x _ { i } )$ is the essential term that determines the size of $w _ { i }$ . We therefore ignore the terms $\lambda$ and $\eta$ for simplicity. Then, the relationship between EFS/IFS and the gradient-based feature attribution methods can be summarized as follows.
+
+Grad (Simonyan et al., 2013) Assuming $\mu _ { i } - x _ { i }$ to be constant across the features, $w _ { i }$ is equivalent to $\frac { \partial f _ { c } ( x ) } { \partial x _ { i } }$ up to the scaling factor $\mu _ { i } - x _ { i }$ .
+
+Grad $\times$ Input (Shrikumar et al., 2016) Assuming $\mu _ { i }$ to be sufficiently small $( \mu _ { i } \to 0 )$ ), $w _ { i }$ is equivalent to $\frac { \partial f _ { c } ( x ) } { \partial x _ { i } } x _ { i }$
+
+Linear Approximation (Bach et al., 2015; Sundararajan et al., 2017; Shrikumar et al., 2017; Montavon et al., 2017; Ribeiro et al., 2016; Lundberg $\pmb { \& }$ Lee, 2017) Several methods consider the linear approximation of the model $f$ in the neighborhood of the input $x$ . Specifically, they consider the linear model
+
+$$
+f _ { c } ( r ) = f _ { c } ( x ) + \langle w , r - x \rangle ,
+$$
+
+and uses the coefficient $w$ as the attribution score. Here, let us assume that the noise $r$ belongs to the $\epsilon$ -ball around $x$ , i.e. $r \in R ( x ; \epsilon ) : = \{ r : \| r - x \| \le \epsilon \}$ . For differentiable models, we can consider the first-order Taylor expansion within $R ( x ; \epsilon )$ :
+
+$$
+f _ { c } ( r ) = f _ { c } ( \boldsymbol { x } ) + \langle \nabla f _ { c } ( \boldsymbol { x } ) , r - \boldsymbol { x } \rangle + O ( \epsilon ^ { 2 } ) .
+$$
+
+Thus, in a rough sense, by ignoring the $O ( \epsilon ^ { 2 } )$ term, the coefficient $w _ { i }$ computed by those linear approximation methods is essentially equivalent to the gradient ∂fc(x) . Technically, those linear approximation methods consider further improvements over the pure gradient, so that the linear approximation to be valid not only in the infinitesimally small neighborhood of $x$ , but in a finite range from $x$ . Thus, the computed coefficient $w _ { i }$ can slightly differ from the gradient, nevertheless, those methods can be still classified as approximations of the gradient.
+
+SmoothGrad (Smilkov et al., 2017; Hooker et al., 2018) In SmoothGrad, the attribution score is defined as the expectation of the squared gradient over perturbed inputs. Recall that the perturbed data can be expressed as $\hat { x } _ { w , r _ { x } }$ using the data-dependent noise $r _ { x }$ . Given the perturbation magnitude $w _ { 0 } > 0$ , the attribution score is defined as follows (Smilkov et al., 2017; Hooker et al., 2018):
+
+$$
+\mathrm { s c o r e s g } : = \mathbb { E } _ { r } \left[ \left( \frac { \partial f _ { c } ( \bar { x } _ { w _ { 0 } , r _ { x } } ) } { \partial ( \bar { x } _ { w _ { 0 } , r _ { x } } ) _ { i } } \right) ^ { 2 } \right]
+$$
+
+Here, we show that this score can be also interpreted as one-step gradient descent/ascent approximation to C-EFS and C-IFS. If we set the initial $w$ as $w _ { i } = w _ { 0 }$ , the first step of the optimization can be expressed as
+
+$$
+\begin{array} { r l } & { w _ { i } \gets w _ { 0 } \pm \eta \left\{ \mathbb { E } _ { r } \left[ \left. \frac { \partial f _ { c } ( \bar { x } _ { w , r _ { x } } ) } { \partial w _ { i } } \right| _ { w = w _ { 0 } } \right] + \lambda \right\} } \\ & { \quad = \pm \eta \mathbb { E } _ { r } \left[ \left. \frac { \partial f _ { c } ( \bar { x } _ { w , r _ { x } } ) } { \partial w _ { i } } \right| _ { w = w _ { 0 } } \right] + ( w _ { 0 } \pm \eta \lambda ) } \\ & { \quad = \pm \eta \mathbb { E } _ { u } \left[ \left. \frac { \partial f _ { c } ( \bar { x } _ { w , x + u } ) } { \partial ( \bar { x } _ { w , x + u } ) _ { i } } \right| _ { w = w _ { 0 } } u _ { i } \right] + ( w _ { 0 } \pm \eta \lambda ) , } \end{array}
+$$
+
+where we used the definition $r _ { x } = x + u$ in the last equality. Because $w _ { 0 } , \eta$ , and $\lambda$ are constants, the first term determines $w _ { i }$ . Moreover, by applying the Cauchy-Schwartz inequality, we obtain
+
+$$
+\left( \mathbb E _ { u } \left[ \left. \frac { \partial f _ { c } ( \bar { x } _ { w _ { 0 } , x + u } ) } { \partial ( \bar { x } _ { w _ { 0 } , x + u } ) _ { i } } \right| _ { w = w _ { 0 } } u _ { i } \right] \right) ^ { 2 } \leq \mathbb E _ { r } \left[ \left( \frac { \partial f _ { c } ( \bar { x } _ { w _ { 0 } , r _ { x } } ) } { \partial ( \bar { x } _ { w _ { 0 } , r _ { x } } ) _ { i } } \right) ^ { 2 } \right] \mathbb E _ { u } [ u _ { i } ^ { 2 } ] .
+$$
+
+If we selected the perturbation $u$ to have a common variance across the features, i.e. $\mathbb { E } _ { u } [ u _ { i } ^ { 2 } ] = \sigma ^ { 2 }$ for all $i \in [ d ]$ , we can conclude that $\mathbb { E } _ { r } \left[ \left( \frac { \partial f _ { c } ( \bar { x } _ { w _ { 0 } , r _ { x } } ) } { \partial ( \bar { x } _ { w _ { 0 } , r _ { x } } ) _ { i } } \right) ^ { 2 } \right]$ is the essential term determining $w$ , which is equivalent to (B.4).
+
+Here, we note out our analysis can explain the success of SmoothGrad. Some studies (Smilkov et al., 2017; Hooker et al., 2018) have reported that SmoothGrad performs better than other gradient-based feature attribution methods in practice. As one-step gradient descent/ascent approximation to C-EFS and C-IFS, SmoothGrad starts the optimization from the non-zero point $w = w _ { 0 }$ while the other methods starts the optimization from zero $w = 0 _ { d }$ . If the initial point $w _ { 0 }$ is carefully chosen, it is apparent that one-step gradient descent/ascent from $w _ { 0 }$ can get closer to the solution than starting the optimization from zero.
+
+# C IMPLEMENTATIONS OF EFS/IFS-BASED METHODS
+
+In Section 5, we adopted the EFS-based and IFS-based methods: Greedy-EFS, which solves the problem (2.2) using a greedy algorithm; Grad-EFS, which solves the problem (3.2) using gradient descent; Greedy-IFS, which solves the problem (2.3) using a greedy algorithm; and Grad- $I F S$ , which solves the problem (3.3) using gradient ascent. Each method is implemented as follows.
+
+Greedy-EFS In Greedy-EFS, we first prepared the feature subsets $S : = \{ S _ { m } \subseteq [ d ] \} _ { m = 1 } ^ { M }$ , where each subset $S _ { m }$ is constructed by sliding the window over the image. In our implementation, we set the window size as $6 4 \times 6 4$ and the stride set to 16. We started the greedy algorithm from $S = \emptyset$ , and iterated the following steps.
+
+We repeated those steps ten times, and obtained $S$ as an approximation of $S _ { \mathrm { E F S } }$ . We used a gray background as the noise $r$ , i.e. $p ( r ) = \delta ( r = \mathrm { g r a y } )$ .
+
+Greedy-IFS In Greedy-IFS, we prepared the feature subsets $S : = \{ S _ { m } \subseteq [ d ] \} _ { m = 1 } ^ { M }$ in the same way as Greedy-EFS. We started the greedy algorithm from $S = [ d ]$ , and iterated the following steps.
+
+We repeated those steps ten times, and obtained $S$ as an approximation of $S _ { \mathrm { I F S } }$ . We used a gray background as the noise $r$ , i.e. $p ( r ) = \delta ( r = \mathrm { g r a y } )$ . We note that Greedy-IFS is essentially the same as the greedy method proposed by Zhou et al. (2014).
+
+Grad-EFS In Grad-EFS, we used the data-dependent noise $r _ { x }$ , where we set the distribution $p ( u )$ to be uniform over $[ - 1 , 1 ] ^ { d }$ . In each step of the gradient descent, we approximated the gradient of C-EFS (3.2) using a batch of random realizations of $r _ { x }$ . In our implementation, we set the penalty weight $\lambda = 1 0 d$ and the batch size in each gradient approximation to be 32. As the optimization algorithm, we used Adam (Kingma & Ba, 2014) with the step size set to 0.5 and the remaining parameters set to default values. We run Adam for 200 steps, and obtained $w$ . We note that GradEFS is essentially the same as Meaningful Perturbation (Fong & Vedaldi, 2017) except that the smoothness penalty term is removed.
+
+Grad-IFS In Grad-IFS, we used the data-dependent noise $r _ { x }$ , where we set the distribution $p ( u )$ to be uniform over $[ - 1 , 1 ] ^ { d }$ . In each step of the gradient ascent, we approximated the gradient of C-IFS (3.3) using a batch of random realizations of $r _ { x }$ . In our implementation, we set the penalty weight $\lambda = d$ and the batch size in each gradient approximation to be 32. As the optimization algorithm, we used Adam (Kingma & Ba, 2014) with the step size set to 0.03 and the remaining parameters set to default values. We run Adam for 1000 steps. In Grad-IFS, we used the averaged parameter over 1000 steps 11000 P t=1 $\textstyle { \frac { 1 } { 1 0 0 0 } } \sum _ { t = 1 } ^ { 1 0 0 0 } w ^ { ( t ) }$ as $w$ . This is a common technique to improve the quality of the solution obtained from stochastic optimization algorithms with convex objective functions. We found that this technique is helpful also for Grad-IFS. We also applied the same averaging technique to PertMap (Ikeno & Hara, 2018).
+
+# D EXPERIMENTAL RESULTS
+
+Here, we present all the results that are omitted from Section 5 due to the space limitation.
+
+# D.1 AUEC AND AOIC
+
+Table 2 and Table 3 show average AUEC and AOIC evaluated with uniform noises and random images, respectively. There are three important observations in these tables.
+
+First, Grad-EFS attained the highest AUEC for VGG16 and Inception V3, and the second highest AUEC for ResNet V2. This indicates that Grad-EFS is nearly optimal under the principle of EFS: Grad-EFS can change the model’s decision by corrupting only a small number of relevant features. Indeed, as shown in Figure 6 and Figure 7, Grad-EFS has a sharp increase in the EFS-Curves. This is a natural consequence from the fact that EFS is very similar to adversarial example, as we discussed in Section 5.
+
+Second, especially for VGG16, the random attribution attained AUEC similar to some of the methods such as Grad $\times$ Input, IntGrad, LRP, and Occlusion. Indeed, as in Figure 6 and Figure 7, the EFS-Curves of the random attribution are close to those methods. It is a bit surprising to observe that we can attain a good trade-off in EFS just by randomly scoring each feature without looking at the images. This observation indicates that there are only subtle differences between good attributions and random attributions under EFS, especially for VGG16.
+
+Third, on AOIC, Grad-IFS consistently outperformed the other methods, and PertMap attained the second best result. As shown in Figure 6 and Figure 7, Grad-IFS is very resistant against the corruption of irrelevant features. This means that Grad-IFS is capable of identifying irrelevant features better than any other methods. Another important point that can be seen in Figure 6 and Figure 7 is that, the IFS-Curves vary significantly across different methods. More importantly, unlike EFS, the IFS-Curve can distinguish random attributions and other attributions well.
+
+Table 2: Average AUEC and AOIC under the uniform noise. The top-three scores are highlighted as ${ 1 } \mathrm { s t } ^ { * }$ , 2nd∗∗, and $3 \mathrm { r d } ^ { * * * }$ .   
+
+<table><tr><td rowspan="2"></td><td colspan="2">VGG16</td><td colspan="2">ResNet V2</td><td colspan="2">Inception V3</td></tr><tr><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td></tr><tr><td>Greedy-EFS</td><td>0.844</td><td>0.366</td><td>0.858**</td><td>0.391</td><td>0.837***</td><td>0.445</td></tr><tr><td>Grad-EFS</td><td>0.946*</td><td>0.195</td><td>0.858**</td><td>0.369</td><td>0.927*</td><td>0.394</td></tr><tr><td>Greedy-IFS</td><td>0.746</td><td>0.622</td><td>0.745</td><td>0.709***</td><td>0.715</td><td>0.685</td></tr><tr><td>Grad-IFS</td><td>0.873</td><td>0.876*</td><td>0.814</td><td>0.829*</td><td>0.817</td><td>0.868*</td></tr><tr><td>Grad</td><td>0.867</td><td>0.341</td><td>0.797</td><td>0.416</td><td>0.799</td><td>0.475</td></tr><tr><td>Grad×Input</td><td>0.823</td><td>0.318</td><td>0.750</td><td>0.404</td><td>0.748</td><td>0.441</td></tr><tr><td>SmoothGrad</td><td>0.882</td><td>0.593***</td><td>0.840</td><td>0.707</td><td>0.829</td><td>0.744***</td></tr><tr><td>GuidedBP</td><td>0.918**</td><td>0.455</td><td>0.874*</td><td>0.595</td><td>0.826</td><td>0.555</td></tr><tr><td>IntGrad</td><td>0.837</td><td>0.346</td><td>0.781</td><td>0.438</td><td>0.775</td><td>0.482</td></tr><tr><td>LRP</td><td>0.823</td><td>0.318</td><td>0.750</td><td>0.404</td><td>0.748</td><td>0.441</td></tr><tr><td>DeepLIFT</td><td>0.862</td><td>0.435</td><td>0.811</td><td>0.518</td><td>0.788</td><td>0.539</td></tr><tr><td>Occlusion</td><td>0.811</td><td>0.559</td><td>0.767</td><td>0.595</td><td>0.709</td><td>0.664</td></tr><tr><td>PertMap</td><td>0.886***</td><td>0.780**</td><td>0.828</td><td>0.765**</td><td>0.846**</td><td>0.817**</td></tr><tr><td>Random</td><td>0.839</td><td>0.160</td><td>0.691</td><td>0.308</td><td>0.714</td><td>0.290</td></tr></table>
+
+Table 3: Average AUEC and AOIC under random images. The top-three scores are highlighted as ${ 1 } \mathrm { s t } ^ { * }$ , $2 \mathrm { n d } ^ { \ast \ast }$ , and $3 \mathrm { r d } ^ { * * * }$ .   
+
+<table><tr><td rowspan="2"></td><td colspan="2">VGG16</td><td colspan="2">ResNet V2</td><td colspan="2">Inception V3</td></tr><tr><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td></tr><tr><td>Greedy-EFS</td><td>0.842</td><td>0.319</td><td>0.857***</td><td>0.388</td><td>0.857***</td><td>0.397</td></tr><tr><td>Grad-EFS</td><td>0.926*</td><td>0.179</td><td>0.861**</td><td>0.275</td><td>0.893*</td><td>0.293</td></tr><tr><td>Greedy-IFS</td><td>0.766</td><td>0.524***</td><td>0.763</td><td>0.589</td><td>0.760</td><td>0.521</td></tr><tr><td>Grad-IFS</td><td>0.858</td><td>0.630*</td><td>0.826</td><td>0.688*</td><td>0.844</td><td>0.705*</td></tr><tr><td>Grad</td><td>0.865</td><td>0.290</td><td>0.800</td><td>0.375</td><td>0.826</td><td>0.393</td></tr><tr><td>Grad×Input</td><td>0.835</td><td>0.296</td><td>0.775</td><td>0.384</td><td>0.789</td><td>0.396</td></tr><tr><td>SmoothGrad</td><td>0.880</td><td>0.486</td><td>0.846</td><td>0.647***</td><td>0.860</td><td>0.650***</td></tr><tr><td>GuidedBP</td><td>0.905**</td><td>0.416</td><td>0.876*</td><td>0.568</td><td>0.839</td><td>0.502</td></tr><tr><td>IntGrad</td><td>0.847</td><td>0.318</td><td>0.807</td><td>0.418</td><td>0.815</td><td>0.435</td></tr><tr><td>LRP</td><td>0.835</td><td>0.296</td><td>0.775</td><td>0.384</td><td>0.789</td><td>0.397</td></tr><tr><td>DeepLIFT</td><td>0.868</td><td>0.378</td><td>0.836</td><td>0.480</td><td>0.826</td><td>0.471</td></tr><tr><td>Occlusion</td><td>0.840</td><td>0.487</td><td>0.787</td><td>0.544</td><td>0.769</td><td>0.553</td></tr><tr><td>PertMap</td><td>0.876***</td><td>0.553**</td><td>0.833</td><td>0.660**</td><td>0.861**</td><td>0.661**</td></tr><tr><td>Random</td><td>0.842</td><td>0.160</td><td>0.760</td><td>0.237</td><td>0.767</td><td>0.234</td></tr></table>
+
+![](images/85289b637c9833e58128f0e3e4b13cbcdbabf9c272b057142fa30d8566b56de4.jpg)  
+Figure 6: Average EFS-Curve and IFS-Curve evaluated with uniform noises.
+
+![](images/37c5d3e7f7f1426a077c45b0c754b4df37697c35f8960d6c7aa487a6466e843c.jpg)  
+Figure 7: Average EFS-Curve and IFS-Curve evaluated with random images.
+
+# D.2 EXAMPLE HEATMAPS
+
+Figures 8–12 show examples of the heatmaps obtained by several feature attribution methods. There are two important observations in the figures.
+
+First, the heatmaps of Grad-EFS are mostly shot noises, which are visibly meaningless. These are natural consequences from the fact that EFS is very similar to adversarial example, as we have discussed in Section 5.
+
+Second, the high AOIC methods in Table 2 and Table 3, namely Grad-IFS, PertMap, and SmoothGrad, have highlighted mostly the faces of the animals. The high AOICs on these methods indicate that the model has made the decision based mostly on the animal face. In contrast, the other methods tend to generate noisy attributions over the entire body of the animals, which are false explanations from the perspective of IFS because their AOICs are far smaller than that of Grad-IFS: the noisy attributions failed to capture essential pixels in the images.
+
+![](images/f0204f3d368fa1f513cbb6f1223930bb97f72c19918239e169a26a09882d0778.jpg)  
+Figure 8: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method.
+
+![](images/4bd97ee0173318dd58a7ca2ff3b9df712f81e38e710a27cf44c8ca6e5abcb44b.jpg)  
+Figure 9: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method.
+
+![](images/669ab9802155c73b66086f0d8efd1853511915a70e60957fcd3b50ecc2bee48e.jpg)  
+Figure 10: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method.
+
+![](images/c25b4d134f7f18eec8fd96de087192a5e8f3db1a29a2bc880bd1e8a40d646c68.jpg)  
+Figure 11: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method.
+
+![](images/ecc62006eadb15c9b38b3e31be026719ec355ea1072a942ef311996aa1102ce8.jpg)  
+Figure 12: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method.

parse/train/H1lS8oA5YQ/H1lS8oA5YQ_content_list.json

@@ -0,0 +1,2002 @@
+[
+    {
+        "type": "text",
+        "text": "FEATURE ATTRIBUTION AS FEATURE SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            767,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Feature attribution methods identify “relevant” features as an explanation of a complex machine learning model. Several feature attribution methods have been proposed; however, only a few studies have attempted to define the “relevance” of each feature mathematically. In this study, we formalize the feature attribution problem as a feature selection problem. In our proposed formalization, there arise two possible definitions of relevance. We name the feature attribution problems based on these two relevances as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS). We show that several existing feature attribution methods can be interpreted as approximation algorithms for EFS and IFS. Moreover, through exhaustive experiments, we show that IFS is better suited as the formalization for the feature attribution problem than EFS. ",
+        "bbox": [
+            233,
+            243,
+            764,
+            396
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            336,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Feature attribution methods (Simonyan et al., 2013; Springenberg et al., 2014), or saliency maps, are one of the most popular approaches for explaining the decisions of complex machine learning models such as deep neural networks. In feature attribution, for each given instance, the feature attribution methods score how strongly each feature is relevant to the model’s decision. An informal definition of the feature attribution problem can be described as follows. We note that this definition is incomplete because the “relevance” of each feature is not defined. ",
+        "bbox": [
+            174,
+            462,
+            825,
+            546
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Feature Attribution Problem Given the model $f$ and the target input $x \\in \\mathbb { R } ^ { d }$ to be explained, score $s _ { i } \\in \\mathbb { R }$ to each feature $x _ { i }$ $( i = 1 , 2 , \\ldots , d )$ so that $s _ { i } \\geq s _ { j }$ if the feature $x _ { i }$ is more relevant to the model’s decision than the feature $x _ { j }$ . ",
+        "bbox": [
+            176,
+            553,
+            820,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With feature attribution methods, the relevant features can be obtained as explanations why the models made certain decisions. For example, in image recognition, feature attribution methods highlight pixels which the models have focused on, by scoring the relevance of each pixel (Simonyan et al., 2013; Springenberg et al., 2014; Bach et al., 2015; Smilkov et al., 2017), and in text classification, they detect the set of words or sentences relevant to the model’s decision by scoring each word or sentence (Ding et al., 2017; Chen et al., 2018). ",
+        "bbox": [
+            174,
+            602,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The major approaches for feature attribution are based on gradient and its modifications (Simonyan et al., 2013; Springenberg et al., 2014; Bach et al., 2015; Smilkov et al., 2017; Shrikumar et al., 2017) and feature occlusions (Zeiler & Fergus, 2014; Zhou et al., 2014). ",
+        "bbox": [
+            178,
+            693,
+            821,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Most of the studies proposed computational algorithms without defining the “relevance” mathematically (except for some axiomatic approaches (Sundararajan et al., 2017; Lundberg & Lee, 2017)). This means that it is not clear what these algorithm outputs, and we cannot compare these outputs rigorously. To clarify the situation and to establish solid feature attribution methods, we pose the following research questions: (Q1) how can we define relevance? (Q2) is there a general framework for the relevance that induces existing feature attribution methods? and (Q3) what is an appropriate definition of relevance? ",
+        "bbox": [
+            174,
+            742,
+            825,
+            839
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this study, we formalize the feature attribution problem as feature selection problem, and thereby answer questions (Q1)–(Q3). In our proposed formalization, there arise two possible definitions of relevance. We name the feature attribution problems based on these two relevances as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS). ",
+        "bbox": [
+            176,
+            847,
+            823,
+            902
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Below, we summarize our contributions. ",
+        "bbox": [
+            176,
+            910,
+            437,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c0fa6b6e8aa8cfcd9d6cca7958837340fe672352ebe8995d2ec037d82fc1c8a8.jpg",
+        "image_caption": [
+            "Figure 1: Reorganizing feature attribution methods as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS). See the references for the details of each method: Grad (Simonyan et al., 2013), Grad $. \\times$ Input (Shrikumar et al., 2016), IntGrad (Sundararajan et al., 2017), SmoothGrad (Smilkov et al., 2017; Hooker et al., 2018), LIME (Ribeiro et al., 2016), SHAP (Lundberg & Lee, 2017), GuidedBP (Springenberg et al., 2014), ExciteBP (Zhang et al., 2016), LRP (Bach et al., 2015), DeepTaylor (Montavon et al., 2017), DeepLIFT (Shrikumar et al., 2017), Occlusion (Zeiler & Fergus, 2014), Detector (Zhou et al., 2014), Anchor (Ribeiro et al., 2018), Meaningful Perturbation (Fong & Vedaldi, 2017), and PertMap (Hara et al., 2018; Ikeno & Hara, 2018) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            99,
+            771,
+            342
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Answer to Q1: We introduce two formalizations, namely EFS and IFS (Section 2). We formalize the feature attribution problem as feature selection problem, because the goal of feature attribution is to identify the relevant features to the model’s decision. Here, we point out that there are two possible approaches for characterizing the relevance of the features. In the first approach, EFS, we exclude some features from the model, and if the model’s decision changes by the exclusion, we infer the excluded features are relevant since they have certain impacts to the decision. In the second approach, IFS, we include some features to the model, and if the model’s decision remains unchanged after the inclusion, we infer the included features are relevant since they are essential to the decision. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            643
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Answer to Q2: The existing methods are based on the relevances of EFS and IFS (Section 3). We show that several existing feature attribution methods can be interpreted as approximation algorithms for EFS or IFS, as summarized in Figure 1. For example, the gradient-based methods are one-step gradient descent for the continuous relaxation of EFS and IFS. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Answer to Q3: The relevance based on IFS is better suited for the feature attribution problem (Section 5). We observe that IFS is better suited as the formalization for the feature attribution problem than EFS. Through exhaustive experiments, we found two crucial properties of EFS. First, the optimal solution to EFS is very similar to adversarial example (Szegedy et al., 2013). As adversarial examples generally provide seemingly meaningless attributions, they are not appropriate for the purpose of explanation. Second, we empirically observe that even a random attribution can perform comparably well with some of the existing feature attribution methods under the evaluation based on EFS. This observation indicates that there are only subtle differences between good attributions and random attributions under EFS. In contrast, unlike EFS, IFS has no trivial drawbacks, and we argue that IFS would be an appropriate formalization for the feature attribution problem. ",
+        "bbox": [
+            173,
+            714,
+            825,
+            853
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we use the following notation, and consider the problem setting as follows. ",
+        "bbox": [
+            173,
+            859,
+            753,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notation For any positive integer $d , \\ [ d ]$ denotes the set $[ d ] ~ = ~ \\{ 1 , 2 , \\ldots , d \\}$ . We denote $d$ - dimensional vectors with all zeros as $0 _ { d }$ . For a proposition $a$ , $\\mathbb { I } ( a )$ denotes the indicator of $a$ , i.e., $\\mathbb { I } ( a ) = 1$ if $a$ is true, and $\\mathbb { I } ( a ) = 0$ if $a$ is false. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Settings In this paper, we consider the classification model $f$ for $C$ categories that return an output $y \\in \\breve { \\mathbb { R } } ^ { C }$ for a given data $\\boldsymbol { x } ~ \\in ~ \\mathbb { R } ^ { d }$ , i.e., $y \\ = \\ f ( x )$ . The classification result is determined by $c = \\operatorname { a r g m a x } _ { j } y _ { j }$ where $y _ { j } = f _ { j } ( x )$ is the $j$ -th element of the output. We assume that the model $f$ is differentiable with respect to the input $x$ : the target models therefore include linear models, kernel models with differentiable kernels, and deep neural networks. We assume that the model $f$ and the target input $x$ to be explained are given and fixed. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 FEATURE ATTRIBUTION AS FEATURE SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            207,
+            616,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(Q1) How can we define the relevance? ",
+        "bbox": [
+            176,
+            238,
+            433,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As an answer to this question, we formalize the feature attribution problem as feature selection problem, and introduce two definitions of relevance. ",
+        "bbox": [
+            174,
+            258,
+            823,
+            287
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Before formalizing the problem, we introduce the idea of data corruption (Samek et al., 2017; Fong & Vedaldi, 2017), which plays an important role in this study. Here, we consider corrupting the input data $x$ by overlaying partial features with a noise $r \\in \\mathbb { R } ^ { d }$ , as follows. ",
+        "bbox": [
+            174,
+            294,
+            825,
+            337
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.1 (Data Corruption). For a vector $x \\in \\mathbb { R } ^ { d }$ , the corruption of $x$ with the set $S \\subseteq [ d ]$ and the vector $r \\in  { \\mathbb { R } ^ { d } }$ is given by $x _ { S , r }$ , which is defined below. ",
+        "bbox": [
+            171,
+            339,
+            823,
+            368
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e6fb1084bacb48e229879d96efede58b68418f78f082519657de056a77b3ccc8.jpg",
+        "text": "$$\n( x _ { S , r } ) _ { i } = \\left\\{ { r _ { i } \\mathrm { \\quad ~ i f ~ } i \\in S } , \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            375,
+            591,
+            409
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We refer to the set $S$ as corrupted features. ",
+        "bbox": [
+            176,
+            412,
+            455,
+            428
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we assume that the noise $r$ follows a distribution $p ( r )$ . In Section 5, we introduce two types of noises $r$ for the images; we overlay the image to be explained with random noises and random real images. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now consider the problem formalization. Recall that the objective of feature attribution is to provide high scores to relevant features to the model’s decision and low scores to irrelevant features. Our idea is to define the relevance and irrelevance using data corruption. Specifically, in this study, we consider two types of feature selection problems based on data corruption. We name those two problems as Exclusive Feature Selection (EFS) and Inclusive Feature Selection (IFS). ",
+        "bbox": [
+            174,
+            487,
+            825,
+            558
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 EXCLUSIVE FEATURE SELECTION (EFS) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            573,
+            496,
+            588
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One way of measuring the relevance of features is to corrupt some of the features by overlaying with uninformative values and observe how the model’s decision changes. If the corruption of certain features leads to a decision change, such features can be considered as “relevant”. We note that corrupting many features easily leads to a decision change. Therefore, our focus is mainly on a small number of crucial features that can change the decision. We formalize this idea as Exclusive Feature Selection (EFS). In EFS, we aim at changing the decision of the model $f$ to a class different from $c$ by corrupting only a small number of features. See Figure 2 for the idea of EFS. The idea of EFS was originally proposed for measuring the performance of feature attribution methods (Samek et al., 2017). Here, we define EFS as follows. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            724
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.2 (Exclusive Feature Selection (EFS)). Find the feature corruption $S \\subseteq [ d ]$ such that (i) the number of corrupted features $| S |$ is small, and (ii) the corrupted data $x _ { S , r }$ has small intensity at class $c$ , i.e. $f _ { c } ( x _ { S , r } )$ is small, so that the corrupted data is classified into a different class. ",
+        "bbox": [
+            171,
+            728,
+            823,
+            771
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fef6e134e3a2e89cdd1254e65d0923a31bd21e55eb844fcd1b372c91657c76d1.jpg",
+        "text": "$$\n\\begin{array} { r } { S _ { \\mathrm { E F S } } : = \\mathrm { a r g m i n } _ { S \\subseteq [ d ] } | S | + \\lambda \\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            773,
+            642,
+            794
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { E } _ { r }$ denotes the expectation over the noise $r$ , and $\\lambda > 0$ is a weight parameter determined by the user. ",
+        "bbox": [
+            174,
+            796,
+            825,
+            825
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this definition, we consider the expected intensity $\\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ]$ over the noise $r$ so to avoid the corruption to overfit a specific realization of the noise $r$ . ",
+        "bbox": [
+            174,
+            834,
+            823,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By using the solution of EFS, we can define relevance as a binary score as follows. That is, in EFS, the relevant features are the ones when excluded from the data lead to the model’s decision change. ",
+        "bbox": [
+            173,
+            871,
+            821,
+            898
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.3 (EFS-Relevance). The relevance of each feature $x _ { i }$ is defined by $s _ { i } : = \\mathbb { I } ( i \\in S _ { \\mathrm { E F S } } )$ ",
+        "bbox": [
+            174,
+            902,
+            820,
+            917
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1abffe631b4af9e961d14fb33f1ae5d1263a08639de15355d9f2b915d6321f6.jpg",
+        "image_caption": [
+            "Figure 2: The idea of EFS: Within the trade-off between intensity $\\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ]$ and the number of corrupted features $| S |$ , find $S$ that minimizes the intensity and its size. The red pixels indicate the corrupted features $S$ . The corrupted features $S$ in the second image is optimal in this curve. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            106,
+            799,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/acb2c47a5e2b29a0481ba61d33e14871d810f97cb4f67d1088a918362c2639a4.jpg",
+        "image_caption": [
+            "Figure 3: The idea of IFS: Within the trade-off between intensity $\\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ]$ and the number of corrupted features $| S |$ , find $S$ that maximizes the intensity and its size. The red pixels indicate the corrupted features $S$ . The corrupted features $S$ in the fourth image is optimal in this curve. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            364,
+            799,
+            537
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 INCLUSIVE FEATURE SELECTION (IFS) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            488,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Data corruption can be used for measuring the relevance of features in a way different from that of EFS. If the corruption of certain features does not change the model’s decision, such features can be considered as “irrelevant”. We note that zero corruption trivially keeps the decision unchanged. Therefore, our focus is mainly on a small number of crucial features that have to be kept to maintain the decision. Therefore, in Inclusive Feature Selection, we aim at maintaining the decision of the model $f$ in the class $c$ while corrupting as many features as possible. See Figure 3 for the idea of IFS. Here, we formally define IFS as follows. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.4 (Inclusive Feature Selection (IFS)). Find the feature corruption $S \\subseteq [ d ]$ such that (i) the number of corrupted features $| S |$ is large, and (ii) the corrupted data $x _ { S , r }$ has high intensity at class $c$ , i.e. $f _ { c } ( x _ { S , r } )$ is large, so that the corrupted data is classified to the class $c$ . ",
+        "bbox": [
+            174,
+            770,
+            825,
+            813
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce6b5ac9910f2bf14811e40dc9aec2145a69262f56b50eed16815f82938fd689.jpg",
+        "text": "$$\n\\begin{array} { r } { S _ { \\mathrm { I F S } } : = \\mathrm { a r g m a x } _ { S \\subseteq [ d ] } | S | + \\lambda \\mathbb { E } _ { r } [ f _ { c } ( x _ { S , r } ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            824,
+            643,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By using the solution of IFS, we can define relevance as follows. In IFS, the relevant features are the ones that when included in the data keep the model’s decision unchanged. ",
+        "bbox": [
+            173,
+            862,
+            823,
+            892
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 2.5 (IFS-Relevance). The relevance of each feature $x _ { i }$ is defined by $s _ { i } : = \\mathbb { I } ( i \\notin S _ { \\mathrm { I F S } } )$ . ",
+        "bbox": [
+            169,
+            897,
+            812,
+            914
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 FEATURE ATTRIBUTION METHODS AS EFS AND IFS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            642,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "(Q2) Is there a general framework for the relevance that induces existing feature attribution methods? ",
+        "bbox": [
+            174,
+            133,
+            820,
+            161
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As an answer to this question, we show that the existing feature attribution methods can be interpreted as approximation algorithms for EFS or IFS. Thus, the relevances considered in the existing methods are approximated versions of EFS-Relevance and IFS-Relevance. To show this, we classify the existing methods into three types of approaches for solving EFS and IFS: occlusion-based, optimization-based, and gradient-based. See Figure 1 for the overview. ",
+        "bbox": [
+            174,
+            169,
+            825,
+            238
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 OCCLUSION-BASED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            178,
+            256,
+            447,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Occlusion-based feature attribution methods (Zeiler & Fergus, 2014; Zhou et al., 2014; Ribeiro et al., 2018) measure the relevance by partially masking features. In those methods, the features are masked by sliding windows or patches, and the change of the output $f _ { c }$ is computed. This can be interpreted as an approximation algorithm for solving the problems (2.2) and (2.3). Instead of searching over exponentially large solution candidates $S \\subseteq [ d ]$ , those methods search only over the subset of the solution candidates. For example, one prepares a set of feature subsets $\\{ S _ { m } : S _ { m } \\subseteq$ $[ d ] \\} _ { m = 1 } ^ { M }$ , and searches for an optimal combination of the subsets by using a greedy algorithm (Zhou14) or by a bandit algorithm (Ribeiro et al., 2018). ",
+        "bbox": [
+            174,
+            281,
+            825,
+            393
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 OPTIMIZATION-BASED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            410,
+            468,
+            424
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In order to introduce the optimization-based feature attribution methods, we consider the continuous relaxation of EFS and IFS, as follows. ",
+        "bbox": [
+            174,
+            435,
+            823,
+            463
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.1 (Continuous Corruption). For a vector $x \\in \\mathbb { R } ^ { d }$ , the continuous corruption of $x$ with the vector $w \\in [ 0 , 1 ] ^ { d }$ and the vector $r \\in \\mathbb { R } ^ { d }$ is given by $\\bar { x } _ { w , r }$ , which is defined below. ",
+        "bbox": [
+            171,
+            468,
+            823,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/73179b273990ad2d9d5eb39f2e4ecd9c26ce2c52539b1fd39a62e9c12a5ee75b.jpg",
+        "text": "$$\n( \\bar { x } _ { w , r } ) _ { i } = ( 1 - w _ { i } ) x _ { i } + w _ { i } r _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            503,
+            599,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here, the vector $w$ can be interpreted as the continuous relaxation of the indicator of the set $S$ . ",
+        "bbox": [
+            178,
+            526,
+            790,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.2 (Continuous EFS (C-EFS)). Find the vector $w \\in [ 0 , 1 ] ^ { d }$ such that (i) the amount of corruption $\\textstyle \\sum _ { i = 1 } ^ { d } w _ { i }$ is small, and (ii) the corrupted data $\\bar { x } _ { w , r }$ has small intensity at class $c$ : ",
+        "bbox": [
+            174,
+            545,
+            831,
+            578
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fdc820e1b96356fbb6f9f841acf977021b2d180d5a3b8f84fbff1a5d62cce531.jpg",
+        "text": "$$\n\\begin{array} { r } { w _ { \\mathrm { E F S } } : = \\operatorname * { a r g m i n } _ { w \\in [ 0 , 1 ] ^ { d } } \\sum _ { i = 1 } ^ { d } w _ { i } + \\lambda \\mathbb { E } _ { r } [ f _ { c } ( \\bar { x } _ { w , r } ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            584,
+            673,
+            607
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 3.3 (Continuous IFS (C-IFS)). Find the vector $w \\in [ 0 , 1 ] ^ { d }$ such that (i) the amount of corruption $\\textstyle \\sum _ { i = 1 } ^ { d } w _ { i }$ is large, and (ii) the corrupted data $\\bar { x } _ { w , r }$ has large intensity at class $c$ : ",
+        "bbox": [
+            171,
+            613,
+            823,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95b9f2cbdf1d69fe79919ab5529d71cef67c9559fa753982a21f5191e44b4af3.jpg",
+        "text": "$$\n\\begin{array} { r } { w _ { \\mathrm { I F S } } : = \\operatorname * { a r g m a x } _ { w \\in [ 0 , 1 ] ^ { d } } \\sum _ { i = 1 } ^ { d } w _ { i } + \\lambda \\mathbb { E } _ { r } [ f _ { c } ( \\bar { x } _ { w , r } ) ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            654,
+            673,
+            676
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For C-EFS and C-IFS, the feature attribution scores can be defined as $s _ { i } = w _ { \\mathrm { E F S } , i }$ and $s _ { i } = 1 -$ $w _ { \\mathrm { I F S } , i }$ , respectively. We note that, for a differentiable model $f$ , the objective functions of C-EFS (3.2) and C-IFS (3.3) are differentiable. Therefore, these problems can be solved using gradientbased optimization methods such as SGD and Adam (Kingma & Ba, 2014). ",
+        "bbox": [
+            173,
+            689,
+            825,
+            744
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fong & Vedaldi (2017) first introduced the formulation of C-EFS, and they proposed Meaningful Perturbation by adding a smoothness penalty term to C-EFS. PertMap (Hara et al., 2018; Ikeno & Hara, 2018), another optimization-based method, can be interpreted as a variant of C-IFS. PertMap is equivalent to C-IFS with the term $\\mathbb { E } _ { r } [ f _ { c } ( \\bar { x } _ { w , r } ) ]$ replaced with the hinge penalty term $\\begin{array} { r } { \\sum _ { j \\neq c } \\bar { \\mathbb { E } } _ { r } [ \\operatorname* { m i n } ( 0 , f _ { c } ( \\bar { x } _ { w , r } ) - f _ { j } ( \\bar { x } _ { w , r } ) ) ] } \\end{array}$ that penalizes $w$ only when the corrupted data is classified into other classes. See Appendix A for the detail. ",
+        "bbox": [
+            174,
+            751,
+            825,
+            837
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 GRADIENT-BASED APPROACHES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            437,
+            868
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Many feature attribution methods are based on the gradient of the model’s output ∂fc(x) . ∂xi Here, we point out that those gradient-based feature attribution methods can be interpreted as one-step gradient descent/ascent approximations for C-EFS and C-IFS. If we consider solving the problems (3.2) and (3.3) using gradient descent/ascent with the initial $w$ set to zeros, i.e. $w = 0 _ { d }$ , then, the first step of the optimization can be expressed as $\\begin{array} { r } { w _ { i }  0 \\pm \\eta \\{ \\mathbb { E } _ { r } [ \\frac { \\partial f _ { c } ( \\bar { x } _ { w , r } ) } { \\partial w _ { i } } \\Big | _ { w = 0 _ { d } } ] + \\lambda \\} \\propto } \\end{array}$ $\\begin{array} { r } { \\frac { \\partial f _ { c } ( x ) } { \\partial x _ { i } } ( \\mu _ { i } - x _ { i } ) + \\lambda } \\end{array}$ , where $\\eta > 0$ is the step size and $\\mu _ { i } : = \\mathbb { E } _ { r } [ r _ { i } ]$ . Here, because the penalty $\\lambda$ and the step size $\\eta$ are common across all the features, ${ \\frac { \\partial f _ { c } ( x ) } { \\partial x _ { i } } } ( \\mu _ { i } - x _ { i } )$ is the essential term that determines the size of $w _ { i }$ . This finding naturally connects EFS/IFS and the gradient-based feature attribution methods. See Appendix $\\mathbf { B }$ for the details. ",
+        "bbox": [
+            174,
+            875,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EFS AND IFS AS EVALUATION METRIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            238,
+            534,
+            255
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The ideas of EFS and IFS can be used as metrics for evaluating the performance of feature attribution methods. Suppose that the feature attribution score $s \\in \\mathbb { R } ^ { d }$ is given. ",
+        "bbox": [
+            174,
+            271,
+            823,
+            299
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "EFS-based Metric The principle of EFS is that “crucial attribution should change the model’s decision by corrupting only a small number of relevant features”. For $q \\in [ 0 , 1 ]$ , let the set of the top- $100 q \\%$ relevant features be $S _ { q } : = \\{ i : s _ { i } \\geq t _ { q } \\}$ , where $t _ { q }$ is the $1 0 0 q$ -th largest percentile in $s$ so that $| S _ { q } | = q d$ . Then, we can draw a curve showing the trade-off between the ratio of corrupted relevant features and the degree of the output change (Samek et al., 2017). For example, as the degree of the output changes, we can use the expected difference in intensity: $g _ { c } ^ { \\mathrm { i n t e n s i t y } } ( \\bar { S _ { q } } ) : = \\mathbb { E } _ { r } [ f _ { c } ( \\bar { x } ) -$ $f _ { c } ( x _ { S _ { q } , r } ) ]$ , and the probability of label mismatch: $g _ { c } ^ { \\mathrm { l a b e l } } ( S _ { q } ) : = \\mathbb { E } _ { r } [ \\mathbb { I } ( c \\neq \\operatorname { a r g m a x } _ { j } f _ { j } ( x _ { S _ { q } , r } ) ) ]$ . The trade-off curve usually shows an increasing trend, and the area under the curve can be used as a measure of how quickly the output changes with an increase in the ratio of corrupted features (see Figure 4). In this paper, we refer to this area as Area Under the EFS-Curve (AUEC). ",
+        "bbox": [
+            173,
+            306,
+            825,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "IFS-based Metric The principle of IFS is that “crucial attribution should maintain the model’s output even if many irrelevant features are corrupted”. Similar to EFS, we can construct an IFSbased metric based on this principle. Let $S _ { q } : = \\{ i : s _ { i } \\geq t _ { q } \\}$ be the top- $100 q \\%$ relevant features, as defined above. We then corrupt irrelevant features other than $S _ { q }$ , i.e. $\\bar { S } _ { q } : = [ d ] \\setminus S _ { q }$ . We can then draw a curve showing the trade-off between the ratio of corrupted irrelevant features and the degree of the output change such as $g _ { c } ^ { \\mathrm { i n t e n s i t y } } \\left( \\bar { S } _ { q } \\right)$ and $g _ { c } ^ { \\mathrm { l a b e l } } ( \\bar { S } _ { q } )$ . The trade-off curve usually shows an increasing trend with an increase in the ratio of corrupted features (see Figure 4). Therefore, the area over the curve can be used as a measure of how resistant the model’s decision is against the feature corruption. In this paper, we refer to this area as Area Over the IFS-Curve (AOIC). ",
+        "bbox": [
+            173,
+            454,
+            825,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EFS VS. IFS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            603,
+            312,
+            619
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "(Q3) What is an appropriate definition of relevance? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            519,
+            651
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To answer this question, we compare EFS and IFS through exhaustive experiments. Our results indicate that EFS has several drawbacks, and we therefore argue that IFS-Relevance is better suited for the feature attribution problem. ",
+        "bbox": [
+            176,
+            659,
+            825,
+            700
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            720,
+            375,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Models and Data As the target model $f$ to be explained, we adopted three pre-trained models, namely VGG16 (Simonyan & Zisserman, 2014), ResNet V2 with depth 152 (He et al., 2016), and Inception V3 (Szegedy et al., 2016), which were distributed at the Tensorflow repository1. As the target data $x$ to be explained, we selected 200 images from the validation set at ILSVRC2014 (Russakovsky et al., 2014) which were correctly classified by the three models. ",
+        "bbox": [
+            174,
+            747,
+            825,
+            818
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Feature Attribution Methods In the experiments, we adopted several feature attribution methods for comparison: Grad (Simonyan et al., 2013), Grad $\\times$ Input (Shrikumar et al., 2016), GuidedBP (Springenberg et al., 2014), SmoothGrad (Smilkov et al., 2017; Hooker et al., 2018), IntGrad (Sundararajan et al., 2017), LRP (Bach et al., 2015), DeepLIFT (Shrikumar et al., 2017), Occlusion (Zeiler & Fergus, 2014), and PertMap (Hara et al., 2018; Ikeno & Hara, 2018). Grad, ",
+        "bbox": [
+            173,
+            825,
+            825,
+            895
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Grad $\\times$ Input, GuidedBP, SmoothGrad, and IntGrad were implemented using saliency2 with default settings, and LRP, DeepLIFT, and Occlusion were implemented using DeepExplain3, where we set the mask size for Occlusion as $6 4 \\times 6 4$ with the stride set to 16. We implemented PertMap based on the sample code4. We also adopted random attribution as the baseline where the score for each feature was generated uniformly random over $[ 0 , 1 ]$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In addition to the existing feature attribution methods, we implemented the following EFS-based and IFS-based methods: Greedy-EFS, which solves the problem (2.2) using a greedy algorithm; GradEFS, which solves the problem (3.2) using gradient descent; Greedy-IFS, which solves the problem (2.3) using a greedy algorithm; and Grad-IFS, which solves the problem (3.3) using gradient ascent. The details of these methods can be found in Appendix C. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Evaluation For evaluating AUEC and AOIC, we prepared two noise distributions $p ( r )$ . The first distribution is a uniform distribution: each $r$ is independently sampled from the uniform distribution over $[ 0 , 1 ] ^ { d }$ . The second distribution is a distribution over real images. We selected 100 images from the validation set at ILSVRC2014, with no overlap with the 200 images to be explained. Then, from those 100 images, we randomly selected an image as the noise $r$ . To compute AUEC and AOIC, we varied the percentile $q$ from zero to one, and for each $q$ , we computed the difference scores $g _ { c } ^ { \\mathrm { l a b e l } } ( S _ { q } )$ and ${ \\dot { g } } _ { c } ^ { \\mathrm { l a b e l } } ( { \\bar { S } } _ { q } )$ using empirical averages under those two noise distributions. ",
+        "bbox": [
+            173,
+            257,
+            825,
+            354
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            373,
+            277,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For each model, we computed the attribution scores for all 200 images using each of the 14 feature attribution methods. We then computed AUEC and AOIC under the two noise distributions. ",
+        "bbox": [
+            176,
+            401,
+            823,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our main result is summarized in Table 1. Table 1 shows the AUEC and AOIC for VGG16 for the 200 images under uniform noise. We moved the results for the other models and the corruption with real images to Appendix D, as those results are similar. Here, we point out that there are three important observations in the table. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            491
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "EFS found adversarial example. Grad-EFS attained the highest AUEC. This indicates that GradEFS is nearly optimal under the principle of EFS: Grad-EFS can change the model’s decision by corrupting only a small number of relevant features. Indeed, as shown in Figure 4, Grad-EFS has a sharp increase in the EFS-Curve 5. Specifically, it shows that Grad-EFS successfully changed the model’s decision for more than $80 \\%$ of the data by corrupting only a few percent of the pixels. Similar tendencies were also observed for ResNet V2 and Inception V3 (see Appendix D). ",
+        "bbox": [
+            173,
+            500,
+            823,
+            583
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "An important observation is that the heatmap of Grad-EFS is just a shot noise, as shown in Figure 5. This is because EFS is very similar to adversarial example (Szegedy et al., 2013). In adversarial example, one seeks the minimum data perturbation that changes the model’s output. In EFS (2.2), instead of the data perturbation, one searches for a small number of corrupted features that reduces the class intensity. Similarly, C-EFS (3.2) searches for a continuous corruption with the minimum $\\ell _ { 1 }$ norm. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            672
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Random attribution performed comparably well with existing methods. The random attribution attained AUEC similar to that of methods such as Grad $\\times$ Input, IntGrad, LRP, and Occlusion, especially for VGG16. Indeed, as shown in Figure 4, the EFS-Curve of random attribution is close to those methods. It is a bit surprising to observe that we can attain a good trade-off in EFS just by randomly scoring each feature without looking at the images. This observation indicates that there are only subtle differences between good attributions and random attributions under EFS, especially for VGG16. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            777
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Grad-IFS significantly outperformed the other methods. On AOIC, Grad-IFS significantly outperformed the other methods, and PertMap attained the second best result. As shown in Figure 4, Grad-IFS is very resistant against the corruption of irrelevant features. Indeed, even if $80 \\%$ of the pixels are corrupted, the model’s decision is kept unchanged for more than $80 \\%$ of the images. This means that Grad-IFS is capable of identifying irrelevant features better than any other methods. Another interesting point that can be seen in Figure 4 is that, the IFS-Curves vary significantly across different methods. More importantly, unlike EFS, the IFS-Curve can distinguish random attributions and other attributions well. ",
+        "bbox": [
+            174,
+            785,
+            823,
+            854
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2fbed8540cc5fb95974ba78508452a9dc879c1c726c4202a6173f8627fc1b4e1.jpg",
+        "table_caption": [
+            "Table 1: Average AUEC and AOIC under the uniform noise. The top-three scores are highlighted as ${ 1 } \\mathrm { s t } ^ { * }$ , $2 \\mathrm { n d } ^ { \\ast \\ast }$ , and $3 \\mathrm { r d } ^ { * * * }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">VGG16</td></tr><tr><td></td><td>AUEC AOIC 0.366</td></tr><tr><td>Greedy-EFS</td><td>0.844 0.946*</td></tr><tr><td>Grad-EFS</td><td>0.195</td></tr><tr><td>Greedy-IFS</td><td>0.746 0.622***</td></tr><tr><td>Grad-IFS</td><td>0.873 0.876*</td></tr><tr><td>Grad</td><td>0.867 0.341</td></tr><tr><td>Grad×Input</td><td>0.823 0.318</td></tr><tr><td>SmoothGrad</td><td>0.882 0.593</td></tr><tr><td>GuidedBP</td><td>0.918** 0.455</td></tr><tr><td>IntGrad</td><td>0.837 0.346</td></tr><tr><td>LRP</td><td>0.823 0.318</td></tr><tr><td>DeepLIFT</td><td>0.862 0.435</td></tr><tr><td>Occlusion</td><td>0.811 0.559</td></tr><tr><td>PertMap</td><td>0.886*** 0.780**</td></tr><tr><td>Random</td><td>0.839 0.160</td></tr></table>",
+        "bbox": [
+            176,
+            202,
+            434,
+            425
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c67eb5a490e7f726ebac40720720b6c0c1e23f12434bacb94afaaaa89859e07.jpg",
+        "image_caption": [
+            "Figure 4: Average EFS-Curve and IFS-Curve. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            468,
+            103,
+            795,
+            428
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/98ee7dd402f94319a422b6ee772a5dcad6000134361a86730d979af8ef291839.jpg",
+        "image_caption": [
+            "Figure 5: Attributions on VGG16: The red colored pixels are found to be strongly relevant with each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            469,
+            815,
+            535
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            178,
+            614,
+            823,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 5 shows the examples of the attributions obtained by each method. It is important to note that the top-three AOIC methods, namely Grad-IFS, PertMap, and SmoothGrad, have highlighted only the dog face. The high AOICs on these methods indicate that the model has made the decision based on the dog face. In contrast, the other methods tend to generate noisy attributions over the entire body of the dog, which are false explanations from the perspective of IFS because their AOICs are far smaller than that of Grad-IFS: the noisy attributions failed to capture essential pixels in the image. ",
+        "bbox": [
+            173,
+            665,
+            825,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            318,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this study, we formalized the feature attribution problem as two types of feature selection problems, which we named as EFS and IFS. Based on EFS and IFS, we clarified that the existing feature attribution methods can be interpreted as approximation algorithms for EFS and IFS. Then, through exhaustive experiments, we clarified that IFS is better suited as the formalization for the feature attribution problem; we observed that EFS has several unfavorable properties and concluded that EFS is not an appropriate formalization. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Bach, Alexander Binder, Gregoire Montavon, Frederick Klauschen, Klaus-Robert M ´ uller, ¨ and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS ONE, 10(7):e0130140, 2015. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jianbo Chen, Le Song, Martin Wainwright, and Michael Jordan. Learning to explain: An information-theoretic perspective on model interpretation. In Proceedings of the 35th International Conference on Machine Learning, pp. 882–891, 2018. ",
+        "bbox": [
+            173,
+            176,
+            823,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yanzhuo Ding, Yang Liu, Huanbo Luan, and Maosong Sun. Visualizing and understanding neural machine translation. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, pp. 1150–1159, 2017. ",
+        "bbox": [
+            176,
+            227,
+            823,
+            270
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ruth C Fong and Andrea Vedaldi. Interpretable explanations of black boxes by meaningful perturbation. In Proceeding of the IEEE International Conference on Computer Vision, pp. 3449 – 3457, 2017. ",
+        "bbox": [
+            174,
+            279,
+            823,
+            320
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Satoshi Hara, Kouichi Ikeno, Tasuku Soma, and Takanori Maehara. Maximally invariant data perturbation as explanation. arXiv:1806.07004, 2018. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            358
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016. ",
+        "bbox": [
+            173,
+            366,
+            823,
+            396
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sara Hooker, Dumitru Erhan, Pieter-Jan Kindermans, and Been Kim. Evaluating feature importance estimates. arXiv:1806.10758, 2018. ",
+        "bbox": [
+            174,
+            404,
+            823,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kouichi Ikeno and Satoshi Hara. Maximizing invariant data perturbation with stochastic optimization. arXiv:1807.05077, 2018. ",
+        "bbox": [
+            171,
+            440,
+            823,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            477,
+            823,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Scott M Lundberg and Su-In Lee. A unified approach to interpreting model predictions. In Proceedings of Advances in Neural Information Processing Systems, pp. 4765–4774, 2017. ",
+        "bbox": [
+            171,
+            515,
+            823,
+            545
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gregoire Montavon, Sebastian Lapuschkin, Alexander Binder, Wojciech Samek, and Klaus-Robert ´ Muller. Explaining nonlinear classification decisions with deep taylor decomposition. ¨ Pattern Recognition, 65:211–222, 2017. ",
+        "bbox": [
+            176,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Why should i trust you?: Explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 1135–1144. ACM, 2016. ",
+        "bbox": [
+            174,
+            603,
+            823,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Anchors: High-precision model-agnostic explanations. In Proceedings of the 32nd AAAI Conference on Artificial Intelligence, pp. 1527– 1535, 2018. ",
+        "bbox": [
+            173,
+            654,
+            823,
+            696
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Sanjeev Satheesh, Jia Deng, Sean Ma, Hao Su, Zhiheng Huang, Jonathan Krause, Andrej Karpathy, Alexander C Berg, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. Technical report, 2014. ",
+        "bbox": [
+            176,
+            704,
+            823,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Samek, Alexander Binder, Gregoire Montavon, Sebastian Lapuschkin, and Klaus-Robert ´ Muller. Evaluating the visualization of what a deep neural network has learned. ¨ IEEE transactions on neural networks and learning systems, 28(11):2660–2673, 2017. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, Anna Shcherbina, and Anshul Kundaje. Not just a black box: Learning important features through propagating activation differences. arXiv:1605.1713, 2016. ",
+        "bbox": [
+            176,
+            806,
+            821,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In Proceedings of International Conference on Machine Learning, pp. 3145–3153, 2017. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan, Andrea Vedaldi, and Andrew Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. arXiv:1312.6034, 2013.   \nDaniel Smilkov, Nikhil Thorat, Been Kim, Fernanda Viegas, and Martin Wattenberg. Smoothgrad: ´ removing noise by adding noise. arXiv:1706.03825, 2017.   \nJost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv:1412.6806, 2014.   \nMukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. arXiv:1703.01365, 2017.   \nChristian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv:1312.6199, 2013.   \nChristian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2818–2826, 2016.   \nMatthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In Proceedings of European Conference on Computer Vision, pp. 818–833. Springer, 2014.   \nJianming Zhang, Zhe Lin, Jonathan Brandt, Xiaohui Shen, and Stan Sclaroff. Top-down neural attention by excitation backprop. In Proceedings of European Conference on Computer Vision, pp. 543–559. Springer, 2016.   \nBolei Zhou, Aditya Khosla, Agata Lapedriza, Aude Oliva, and Antonio Torralba. Object detectors emerge in deep scene cnns. arXiv:1412.6856, 2014. ",
+        "bbox": [
+            171,
+            103,
+            826,
+            467
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SUPPLEMENTARY MATERIAL FOR “FEATURE ATTRIBUTION AS FEATURE SELECTION” ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            137
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Preliminaries We define the data-dependent noise by $r _ { x }$ as follows: ",
+        "bbox": [
+            174,
+            184,
+            632,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bcb01817e29bf08e9b4f0bc1ba9c30eadd155ff06974912c12c4fb39b13ae095.jpg",
+        "text": "$$\nr _ { x } : = x + u ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            202,
+            542,
+            217
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where we assume that the perturbation $u$ follows a distribution $p ( u )$ with $\\mathbb { E } _ { u } [ u ] = 0$ . The continuous corruption with the noise $r _ { x }$ is then expressed as ",
+        "bbox": [
+            173,
+            218,
+            823,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d75227fbde5245d9b438fc53db827f15e22867722d49fe15e1a85d5b6091ef3.jpg",
+        "text": "$$\n( \\bar { x } _ { w , r _ { x } } ) _ { i } = ( 1 - w _ { i } ) x _ { i } + w _ { i } r _ { x , i } = x _ { i } + w _ { i } u _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            250,
+            650,
+            266
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "That is, the continuous corruption $\\hat { x } _ { w , r _ { x } }$ is centered at the data $x$ . Moreover, $\\hat { x } _ { w , r _ { x } }$ distributes around $x$ with the magnitude $w$ . The data-dependent noise and this continuous corruption plays an important role when interpreting some of the existing feature attribution methods as EFS and IFS. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A OPTIMIZATION-BASED FEATURE ATTRIBUTION METHODS AS EFS/IFS ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            327,
+            800,
+            345
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Meaningful Perturbation (Fong & Vedaldi, 2017) is a variant of C-EFS defined below: ",
+        "bbox": [
+            174,
+            358,
+            736,
+            373
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/600635d873b35ee4944443015e9284ad7fd11c102919cec8ae67b573375b780d.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { w \\in [ 0 , 1 ] ^ { d } } \\sum _ { i = 1 } ^ { d } w _ { i } + \\lambda f _ { c } ( \\bar { x } _ { w , r } ) + \\phi _ { \\mathrm { s m o o t h } } ( w ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            375,
+            643,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "The differences from C-EFS (3.2) are (i) it uses a fixed noise $r$ instead of the expectation, and (ii) the additional penalty term $\\phi _ { \\mathrm { s m o o t h } } ( w )$ is added so that $w$ to be smooth. Here, the smoothness penalty is essential for Meaningful Perturbation. Fong $\\&$ Vedaldi (2017) have reported that the solution to the problem (A.1) without the smoothness penalty tends to be seemingly meaningless attributions. This is because C-EFS is very similar to the $\\ell _ { 1 }$ penalized adversarial example, as we have discussed in Section 5. Therefore, we need to design an appropriate penalty term $\\phi _ { \\mathrm { s m o o t h } }$ to obtain reasonable attributions using Meaningful Perturbation. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            516
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "PertMap (Hara et al., 2018; Ikeno & Hara, 2018) can be interpreted as a variant of C-IFS. PertMap finds irrelevant features by maximizing the data perturbation. Let $\\hat { x } _ { w , r _ { x } }$ be the continuous corruption of the data $x$ with a data-dependent noise $r _ { x }$ , where the parameter $w$ determine the magnitude of the data perturbation. In PertMap, one seeks for the maximum data perturbation that maintains the classification result unchanged from the original class $c$ . The optimization problem of $w$ is defined as follows (Ikeno & Hara, 2018): ",
+        "bbox": [
+            173,
+            522,
+            825,
+            606
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/990b6b0c2451855e4ad1b255693440d8446d19ea422ed1cfcf524c2231ec0fc6.jpg",
+        "text": "$$\n\\operatorname* { m a x } _ { w \\in [ 0 , 1 ] ^ { d } } \\sum _ { i = 1 } ^ { d } w _ { i } + \\lambda \\sum _ { j \\neq c } \\mathbb { E } _ { r } [ \\operatorname* { m i n } ( 0 , f _ { c } ( \\bar { x } _ { w , r } ) - f _ { j } ( \\bar { x } _ { w , r } ) ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            607,
+            689,
+            652
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This problem is equivalent to C-EFS except for the term $\\mathbb { E } _ { r } [ f _ { c } ( \\bar { x } _ { w , r } ) ]$ replaced with the hinge penalty term $\\begin{array} { r } { \\sum _ { j \\neq c } \\tilde { \\mathbb { E } } _ { r } [ \\operatorname* { m i n } ( 0 , f _ { c } ( \\bar { x } _ { w , r } ) - f _ { j } ( \\bar { x } _ { w , r } ) ) ] } \\end{array}$ that penalizes $w$ only when the corrupted data is classified into other classes. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            698
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B GRADIENT-BASED FEATURE ATTRIBUTION METHODS AS EFS/IFS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            715,
+            761,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Many feature attribution methods are based on the gradient of the model’s output ∂fc(x) . Here, we show that those gradient-based feature attribution methods can be interpreted as one-step gradient descent/ascent approximations to C-EFS and C-IFS. If we consider solving the problems (3.2) and (3.3) using gradient descent/ascent with the initial $w$ set to zeros, i.e. $w = 0 _ { d }$ , then, the first step of the optimization can be expressed as ",
+        "bbox": [
+            173,
+            744,
+            826,
+            818
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20530a6a610f187c87d11f380ad5c9c8290721b72ef091d4fd0bc5cbd8f19db4.jpg",
+        "text": "$$\nw _ { i }  0 \\pm \\eta \\{ \\mathbb { E } _ { r } [  \\frac { \\partial f _ { c } ( \\bar { x } _ { w , r } ) } { \\partial w _ { i } } | _ { w = 0 _ { d } } ] + \\lambda \\} \\propto \\frac { \\partial f _ { c } ( \\boldsymbol { x } ) } { \\partial x _ { i } } ( \\mu _ { i } - x _ { i } ) + \\lambda ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            819,
+            728,
+            862
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta > 0$ is the step size and $\\mu _ { i } : = \\mathbb { E } _ { r } [ r _ { i } ]$ . Here, because the penalty $\\lambda$ and the step size $\\eta$ are common across all the features, $\\frac { \\partial f _ { c } ( x ) } { \\partial x _ { i } } ( \\mu _ { i } - x _ { i } )$ is the essential term that determines the size of $w _ { i }$ . We therefore ignore the terms $\\lambda$ and $\\eta$ for simplicity. Then, the relationship between EFS/IFS and the gradient-based feature attribution methods can be summarized as follows. ",
+        "bbox": [
+            174,
+            863,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Grad (Simonyan et al., 2013) Assuming $\\mu _ { i } - x _ { i }$ to be constant across the features, $w _ { i }$ is equivalent to $\\frac { \\partial f _ { c } ( x ) } { \\partial x _ { i } }$ up to the scaling factor $\\mu _ { i } - x _ { i }$ . ",
+        "bbox": [
+            173,
+            103,
+            825,
+            136
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Grad $\\times$ Input (Shrikumar et al., 2016) Assuming $\\mu _ { i }$ to be sufficiently small $( \\mu _ { i } \\to 0 )$ ), $w _ { i }$ is equivalent to $\\frac { \\partial f _ { c } ( x ) } { \\partial x _ { i } } x _ { i }$ ",
+        "bbox": [
+            174,
+            151,
+            823,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Linear Approximation (Bach et al., 2015; Sundararajan et al., 2017; Shrikumar et al., 2017; Montavon et al., 2017; Ribeiro et al., 2016; Lundberg $\\pmb { \\& }$ Lee, 2017) Several methods consider the linear approximation of the model $f$ in the neighborhood of the input $x$ . Specifically, they consider the linear model ",
+        "bbox": [
+            173,
+            198,
+            825,
+            256
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b535f24364f015bc50959414d8738b716aa087367a1eb76d9f5e73d0775305e5.jpg",
+        "text": "$$\nf _ { c } ( r ) = f _ { c } ( x ) + \\langle w , r - x \\rangle ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            403,
+            261,
+            593,
+            279
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "and uses the coefficient $w$ as the attribution score. Here, let us assume that the noise $r$ belongs to the $\\epsilon$ -ball around $x$ , i.e. $r \\in R ( x ; \\epsilon ) : = \\{ r : \\| r - x \\| \\le \\epsilon \\}$ . For differentiable models, we can consider the first-order Taylor expansion within $R ( x ; \\epsilon )$ : ",
+        "bbox": [
+            173,
+            282,
+            825,
+            327
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9cbfb6169ef02a2a1a3290c61354f2e03cb98da1cf4d33b809f20f92a7062399.jpg",
+        "text": "$$\nf _ { c } ( r ) = f _ { c } ( \\boldsymbol { x } ) + \\langle \\nabla f _ { c } ( \\boldsymbol { x } ) , r - \\boldsymbol { x } \\rangle + O ( \\epsilon ^ { 2 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            330,
+            643,
+            349
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thus, in a rough sense, by ignoring the $O ( \\epsilon ^ { 2 } )$ term, the coefficient $w _ { i }$ computed by those linear approximation methods is essentially equivalent to the gradient ∂fc(x) . Technically, those linear approximation methods consider further improvements over the pure gradient, so that the linear approximation to be valid not only in the infinitesimally small neighborhood of $x$ , but in a finite range from $x$ . Thus, the computed coefficient $w _ { i }$ can slightly differ from the gradient, nevertheless, those methods can be still classified as approximations of the gradient. ",
+        "bbox": [
+            173,
+            354,
+            825,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "SmoothGrad (Smilkov et al., 2017; Hooker et al., 2018) In SmoothGrad, the attribution score is defined as the expectation of the squared gradient over perturbed inputs. Recall that the perturbed data can be expressed as $\\hat { x } _ { w , r _ { x } }$ using the data-dependent noise $r _ { x }$ . Given the perturbation magnitude $w _ { 0 } > 0$ , the attribution score is defined as follows (Smilkov et al., 2017; Hooker et al., 2018): ",
+        "bbox": [
+            173,
+            458,
+            825,
+            515
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8499c647d6a47834ed43920ac66b84488ca0d9c6a305a14eb804fc683787d8f.jpg",
+        "text": "$$\n\\mathrm { s c o r e s g } : = \\mathbb { E } _ { r } \\left[ \\left( \\frac { \\partial f _ { c } ( \\bar { x } _ { w _ { 0 } , r _ { x } } ) } { \\partial ( \\bar { x } _ { w _ { 0 } , r _ { x } } ) _ { i } } \\right) ^ { 2 } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            520,
+            617,
+            563
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here, we show that this score can be also interpreted as one-step gradient descent/ascent approximation to C-EFS and C-IFS. If we set the initial $w$ as $w _ { i } = w _ { 0 }$ , the first step of the optimization can be expressed as ",
+        "bbox": [
+            173,
+            566,
+            825,
+            608
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c248da325534b182779851450701a6d53b55b4e2f35af6a62e87e503078e174f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { w _ { i } \\gets w _ { 0 } \\pm \\eta \\left\\{ \\mathbb { E } _ { r } \\left[ \\left. \\frac { \\partial f _ { c } ( \\bar { x } _ { w , r _ { x } } ) } { \\partial w _ { i } } \\right| _ { w = w _ { 0 } } \\right] + \\lambda \\right\\} } \\\\ & { \\quad = \\pm \\eta \\mathbb { E } _ { r } \\left[ \\left. \\frac { \\partial f _ { c } ( \\bar { x } _ { w , r _ { x } } ) } { \\partial w _ { i } } \\right| _ { w = w _ { 0 } } \\right] + ( w _ { 0 } \\pm \\eta \\lambda ) } \\\\ & { \\quad = \\pm \\eta \\mathbb { E } _ { u } \\left[ \\left. \\frac { \\partial f _ { c } ( \\bar { x } _ { w , x + u } ) } { \\partial ( \\bar { x } _ { w , x + u } ) _ { i } } \\right| _ { w = w _ { 0 } } u _ { i } \\right] + ( w _ { 0 } \\pm \\eta \\lambda ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            613,
+            674,
+            742
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where we used the definition $r _ { x } = x + u$ in the last equality. Because $w _ { 0 } , \\eta$ , and $\\lambda$ are constants, the first term determines $w _ { i }$ . Moreover, by applying the Cauchy-Schwartz inequality, we obtain ",
+        "bbox": [
+            173,
+            746,
+            826,
+            775
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/477acc5c82186219f841c8eae7861fcbb97fc3996fbc48242ab9bc2de61501be.jpg",
+        "text": "$$\n\\left( \\mathbb E _ { u } \\left[ \\left. \\frac { \\partial f _ { c } ( \\bar { x } _ { w _ { 0 } , x + u } ) } { \\partial ( \\bar { x } _ { w _ { 0 } , x + u } ) _ { i } } \\right| _ { w = w _ { 0 } } u _ { i } \\right] \\right) ^ { 2 } \\leq \\mathbb E _ { r } \\left[ \\left( \\frac { \\partial f _ { c } ( \\bar { x } _ { w _ { 0 } , r _ { x } } ) } { \\partial ( \\bar { x } _ { w _ { 0 } , r _ { x } } ) _ { i } } \\right) ^ { 2 } \\right] \\mathbb E _ { u } [ u _ { i } ^ { 2 } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            266,
+            779,
+            732,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "If we selected the perturbation $u$ to have a common variance across the features, i.e. $\\mathbb { E } _ { u } [ u _ { i } ^ { 2 } ] = \\sigma ^ { 2 }$ for all $i \\in [ d ]$ , we can conclude that $\\mathbb { E } _ { r } \\left[ \\left( \\frac { \\partial f _ { c } ( \\bar { x } _ { w _ { 0 } , r _ { x } } ) } { \\partial ( \\bar { x } _ { w _ { 0 } , r _ { x } } ) _ { i } } \\right) ^ { 2 } \\right]$ is the essential term determining $w$ , which is equivalent to (B.4). ",
+        "bbox": [
+            173,
+            829,
+            826,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here, we note out our analysis can explain the success of SmoothGrad. Some studies (Smilkov et al., 2017; Hooker et al., 2018) have reported that SmoothGrad performs better than other gradient-based feature attribution methods in practice. As one-step gradient descent/ascent approximation to C-EFS and C-IFS, SmoothGrad starts the optimization from the non-zero point $w = w _ { 0 }$ while the other methods starts the optimization from zero $w = 0 _ { d }$ . If the initial point $w _ { 0 }$ is carefully chosen, it is apparent that one-step gradient descent/ascent from $w _ { 0 }$ can get closer to the solution than starting the optimization from zero. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C IMPLEMENTATIONS OF EFS/IFS-BASED METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            193,
+            630,
+            209
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In Section 5, we adopted the EFS-based and IFS-based methods: Greedy-EFS, which solves the problem (2.2) using a greedy algorithm; Grad-EFS, which solves the problem (3.2) using gradient descent; Greedy-IFS, which solves the problem (2.3) using a greedy algorithm; and Grad- $I F S$ , which solves the problem (3.3) using gradient ascent. Each method is implemented as follows. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            280
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Greedy-EFS In Greedy-EFS, we first prepared the feature subsets $S : = \\{ S _ { m } \\subseteq [ d ] \\} _ { m = 1 } ^ { M }$ , where each subset $S _ { m }$ is constructed by sliding the window over the image. In our implementation, we set the window size as $6 4 \\times 6 4$ and the stride set to 16. We started the greedy algorithm from $S = \\emptyset$ , and iterated the following steps. ",
+        "bbox": [
+            173,
+            292,
+            825,
+            351
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We repeated those steps ten times, and obtained $S$ as an approximation of $S _ { \\mathrm { E F S } }$ . We used a gray background as the noise $r$ , i.e. $p ( r ) = \\delta ( r = \\mathrm { g r a y } )$ . ",
+        "bbox": [
+            173,
+            406,
+            821,
+            436
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Greedy-IFS In Greedy-IFS, we prepared the feature subsets $S : = \\{ S _ { m } \\subseteq [ d ] \\} _ { m = 1 } ^ { M }$ in the same way as Greedy-EFS. We started the greedy algorithm from $S = [ d ]$ , and iterated the following steps. ",
+        "bbox": [
+            173,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We repeated those steps ten times, and obtained $S$ as an approximation of $S _ { \\mathrm { I F S } }$ . We used a gray background as the noise $r$ , i.e. $p ( r ) = \\delta ( r = \\mathrm { g r a y } )$ . We note that Greedy-IFS is essentially the same as the greedy method proposed by Zhou et al. (2014). ",
+        "bbox": [
+            174,
+            535,
+            825,
+            579
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Grad-EFS In Grad-EFS, we used the data-dependent noise $r _ { x }$ , where we set the distribution $p ( u )$ to be uniform over $[ - 1 , 1 ] ^ { d }$ . In each step of the gradient descent, we approximated the gradient of C-EFS (3.2) using a batch of random realizations of $r _ { x }$ . In our implementation, we set the penalty weight $\\lambda = 1 0 d$ and the batch size in each gradient approximation to be 32. As the optimization algorithm, we used Adam (Kingma & Ba, 2014) with the step size set to 0.5 and the remaining parameters set to default values. We run Adam for 200 steps, and obtained $w$ . We note that GradEFS is essentially the same as Meaningful Perturbation (Fong & Vedaldi, 2017) except that the smoothness penalty term is removed. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            704
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Grad-IFS In Grad-IFS, we used the data-dependent noise $r _ { x }$ , where we set the distribution $p ( u )$ to be uniform over $[ - 1 , 1 ] ^ { d }$ . In each step of the gradient ascent, we approximated the gradient of C-IFS (3.3) using a batch of random realizations of $r _ { x }$ . In our implementation, we set the penalty weight $\\lambda = d$ and the batch size in each gradient approximation to be 32. As the optimization algorithm, we used Adam (Kingma & Ba, 2014) with the step size set to 0.03 and the remaining parameters set to default values. We run Adam for 1000 steps. In Grad-IFS, we used the averaged parameter over 1000 steps 11000 P t=1 $\\textstyle { \\frac { 1 } { 1 0 0 0 } } \\sum _ { t = 1 } ^ { 1 0 0 0 } w ^ { ( t ) }$ as $w$ . This is a common technique to improve the quality of the solution obtained from stochastic optimization algorithms with convex objective functions. We found that this technique is helpful also for Grad-IFS. We also applied the same averaging technique to PertMap (Ikeno & Hara, 2018). ",
+        "bbox": [
+            173,
+            718,
+            825,
+            859
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            878,
+            423,
+            895
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Here, we present all the results that are omitted from Section 5 due to the space limitation. ",
+        "bbox": [
+            169,
+            909,
+            764,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D.1 AUEC AND AOIC ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            346,
+            117
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Table 2 and Table 3 show average AUEC and AOIC evaluated with uniform noises and random images, respectively. There are three important observations in these tables. ",
+        "bbox": [
+            173,
+            128,
+            823,
+            157
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "First, Grad-EFS attained the highest AUEC for VGG16 and Inception V3, and the second highest AUEC for ResNet V2. This indicates that Grad-EFS is nearly optimal under the principle of EFS: Grad-EFS can change the model’s decision by corrupting only a small number of relevant features. Indeed, as shown in Figure 6 and Figure 7, Grad-EFS has a sharp increase in the EFS-Curves. This is a natural consequence from the fact that EFS is very similar to adversarial example, as we discussed in Section 5. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            247
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Second, especially for VGG16, the random attribution attained AUEC similar to some of the methods such as Grad $\\times$ Input, IntGrad, LRP, and Occlusion. Indeed, as in Figure 6 and Figure 7, the EFS-Curves of the random attribution are close to those methods. It is a bit surprising to observe that we can attain a good trade-off in EFS just by randomly scoring each feature without looking at the images. This observation indicates that there are only subtle differences between good attributions and random attributions under EFS, especially for VGG16. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            339
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Third, on AOIC, Grad-IFS consistently outperformed the other methods, and PertMap attained the second best result. As shown in Figure 6 and Figure 7, Grad-IFS is very resistant against the corruption of irrelevant features. This means that Grad-IFS is capable of identifying irrelevant features better than any other methods. Another important point that can be seen in Figure 6 and Figure 7 is that, the IFS-Curves vary significantly across different methods. More importantly, unlike EFS, the IFS-Curve can distinguish random attributions and other attributions well. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            429
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/bd365d3f254ae406b769e8553cb603d7922085fdea3134ba988cb2b9dd585e90.jpg",
+        "table_caption": [
+            "Table 2: Average AUEC and AOIC under the uniform noise. The top-three scores are highlighted as ${ 1 } \\mathrm { s t } ^ { * }$ , 2nd∗∗, and $3 \\mathrm { r d } ^ { * * * }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">VGG16</td><td colspan=\"2\">ResNet V2</td><td colspan=\"2\">Inception V3</td></tr><tr><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td></tr><tr><td>Greedy-EFS</td><td>0.844</td><td>0.366</td><td>0.858**</td><td>0.391</td><td>0.837***</td><td>0.445</td></tr><tr><td>Grad-EFS</td><td>0.946*</td><td>0.195</td><td>0.858**</td><td>0.369</td><td>0.927*</td><td>0.394</td></tr><tr><td>Greedy-IFS</td><td>0.746</td><td>0.622</td><td>0.745</td><td>0.709***</td><td>0.715</td><td>0.685</td></tr><tr><td>Grad-IFS</td><td>0.873</td><td>0.876*</td><td>0.814</td><td>0.829*</td><td>0.817</td><td>0.868*</td></tr><tr><td>Grad</td><td>0.867</td><td>0.341</td><td>0.797</td><td>0.416</td><td>0.799</td><td>0.475</td></tr><tr><td>Grad×Input</td><td>0.823</td><td>0.318</td><td>0.750</td><td>0.404</td><td>0.748</td><td>0.441</td></tr><tr><td>SmoothGrad</td><td>0.882</td><td>0.593***</td><td>0.840</td><td>0.707</td><td>0.829</td><td>0.744***</td></tr><tr><td>GuidedBP</td><td>0.918**</td><td>0.455</td><td>0.874*</td><td>0.595</td><td>0.826</td><td>0.555</td></tr><tr><td>IntGrad</td><td>0.837</td><td>0.346</td><td>0.781</td><td>0.438</td><td>0.775</td><td>0.482</td></tr><tr><td>LRP</td><td>0.823</td><td>0.318</td><td>0.750</td><td>0.404</td><td>0.748</td><td>0.441</td></tr><tr><td>DeepLIFT</td><td>0.862</td><td>0.435</td><td>0.811</td><td>0.518</td><td>0.788</td><td>0.539</td></tr><tr><td>Occlusion</td><td>0.811</td><td>0.559</td><td>0.767</td><td>0.595</td><td>0.709</td><td>0.664</td></tr><tr><td>PertMap</td><td>0.886***</td><td>0.780**</td><td>0.828</td><td>0.765**</td><td>0.846**</td><td>0.817**</td></tr><tr><td>Random</td><td>0.839</td><td>0.160</td><td>0.691</td><td>0.308</td><td>0.714</td><td>0.290</td></tr></table>",
+        "bbox": [
+            217,
+            210,
+            779,
+            435
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/8dc2e8d64bb51e061d51e853656d5a3a7d434433a28cd9d6e74e6be4f8ebcea3.jpg",
+        "table_caption": [
+            "Table 3: Average AUEC and AOIC under random images. The top-three scores are highlighted as ${ 1 } \\mathrm { s t } ^ { * }$ , $2 \\mathrm { n d } ^ { \\ast \\ast }$ , and $3 \\mathrm { r d } ^ { * * * }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"2\">VGG16</td><td colspan=\"2\">ResNet V2</td><td colspan=\"2\">Inception V3</td></tr><tr><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td><td>AUEC</td><td>AOIC</td></tr><tr><td>Greedy-EFS</td><td>0.842</td><td>0.319</td><td>0.857***</td><td>0.388</td><td>0.857***</td><td>0.397</td></tr><tr><td>Grad-EFS</td><td>0.926*</td><td>0.179</td><td>0.861**</td><td>0.275</td><td>0.893*</td><td>0.293</td></tr><tr><td>Greedy-IFS</td><td>0.766</td><td>0.524***</td><td>0.763</td><td>0.589</td><td>0.760</td><td>0.521</td></tr><tr><td>Grad-IFS</td><td>0.858</td><td>0.630*</td><td>0.826</td><td>0.688*</td><td>0.844</td><td>0.705*</td></tr><tr><td>Grad</td><td>0.865</td><td>0.290</td><td>0.800</td><td>0.375</td><td>0.826</td><td>0.393</td></tr><tr><td>Grad×Input</td><td>0.835</td><td>0.296</td><td>0.775</td><td>0.384</td><td>0.789</td><td>0.396</td></tr><tr><td>SmoothGrad</td><td>0.880</td><td>0.486</td><td>0.846</td><td>0.647***</td><td>0.860</td><td>0.650***</td></tr><tr><td>GuidedBP</td><td>0.905**</td><td>0.416</td><td>0.876*</td><td>0.568</td><td>0.839</td><td>0.502</td></tr><tr><td>IntGrad</td><td>0.847</td><td>0.318</td><td>0.807</td><td>0.418</td><td>0.815</td><td>0.435</td></tr><tr><td>LRP</td><td>0.835</td><td>0.296</td><td>0.775</td><td>0.384</td><td>0.789</td><td>0.397</td></tr><tr><td>DeepLIFT</td><td>0.868</td><td>0.378</td><td>0.836</td><td>0.480</td><td>0.826</td><td>0.471</td></tr><tr><td>Occlusion</td><td>0.840</td><td>0.487</td><td>0.787</td><td>0.544</td><td>0.769</td><td>0.553</td></tr><tr><td>PertMap</td><td>0.876***</td><td>0.553**</td><td>0.833</td><td>0.660**</td><td>0.861**</td><td>0.661**</td></tr><tr><td>Random</td><td>0.842</td><td>0.160</td><td>0.760</td><td>0.237</td><td>0.767</td><td>0.234</td></tr></table>",
+        "bbox": [
+            215,
+            625,
+            781,
+            849
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/85289b637c9833e58128f0e3e4b13cbcdbabf9c272b057142fa30d8566b56de4.jpg",
+        "image_caption": [
+            "Figure 6: Average EFS-Curve and IFS-Curve evaluated with uniform noises. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            114,
+            823,
+            885
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/37c5d3e7f7f1426a077c45b0c754b4df37697c35f8960d6c7aa487a6466e843c.jpg",
+        "image_caption": [
+            "Figure 7: Average EFS-Curve and IFS-Curve evaluated with random images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            116,
+            823,
+            885
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D.2 EXAMPLE HEATMAPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            369,
+            117
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Figures 8–12 show examples of the heatmaps obtained by several feature attribution methods. There are two important observations in the figures. ",
+        "bbox": [
+            171,
+            130,
+            823,
+            159
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "First, the heatmaps of Grad-EFS are mostly shot noises, which are visibly meaningless. These are natural consequences from the fact that EFS is very similar to adversarial example, as we have discussed in Section 5. ",
+        "bbox": [
+            174,
+            165,
+            821,
+            205
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Second, the high AOIC methods in Table 2 and Table 3, namely Grad-IFS, PertMap, and SmoothGrad, have highlighted mostly the faces of the animals. The high AOICs on these methods indicate that the model has made the decision based mostly on the animal face. In contrast, the other methods tend to generate noisy attributions over the entire body of the animals, which are false explanations from the perspective of IFS because their AOICs are far smaller than that of Grad-IFS: the noisy attributions failed to capture essential pixels in the images. ",
+        "bbox": [
+            173,
+            213,
+            825,
+            297
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0204f3d368fa1f513cbb6f1223930bb97f72c19918239e169a26a09882d0778.jpg",
+        "image_caption": [
+            "Figure 8: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            194,
+            813,
+            791
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/4bd97ee0173318dd58a7ca2ff3b9df712f81e38e710a27cf44c8ca6e5abcb44b.jpg",
+        "image_caption": [
+            "Figure 9: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            194,
+            813,
+            791
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/669ab9802155c73b66086f0d8efd1853511915a70e60957fcd3b50ecc2bee48e.jpg",
+        "image_caption": [
+            "Figure 10: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            194,
+            813,
+            791
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/c25b4d134f7f18eec8fd96de087192a5e8f3db1a29a2bc880bd1e8a40d646c68.jpg",
+        "image_caption": [
+            "Figure 11: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            190,
+            813,
+            796
+        ],
+        "page_idx": 21
+    },
+    {
+        "type": "image",
+        "img_path": "images/ecc62006eadb15c9b38b3e31be026719ec355ea1072a942ef311996aa1102ce8.jpg",
+        "image_caption": [
+            "Figure 12: Example Heatmaps: The red colored pixels are found to be strongly relevant with each method. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            190,
+            813,
+            797
+        ],
+        "page_idx": 22
+    }
+]

parse/train/Sy4tzwqxe/Sy4tzwqxe.md

@@ -0,0 +1,314 @@
+# TWO METHODS FOR WILD VARIATIONAL INFERENCE
+
+Qiang Liu Yihao Feng   
+Computer Science, Dartmouth College   
+Hanover, NH, 03755   
+{qiang.liu, yihao.feng.gr}@dartmouth.edu
+
+# ABSTRACT
+
+Variational inference provides a powerful tool for approximate probabilistic inference on complex, structured models. Typical variational inference methods, however, require to use inference networks with computationally tractable probability density functions. This largely limits the design and implementation of variational inference methods. We consider wild variational inference methods that do not require tractable density functions on the inference networks, and hence can be applied in more challenging cases. As an example of application, we treat stochastic gradient Langevin dynamics (SGLD) as an inference network, and use our methods to automatically adjust the step sizes of SGLD, yielding significant improvement over the hand-designed step size schemes.
+
+# 1 INTRODUCTION
+
+Probabilistic modeling provides a principled approach for reasoning under uncertainty, and has been increasingly dominant in modern machine learning where highly complex, structured probabilistic models are often the essential components for solving complex problems with increasingly larger datasets. A key challenge, however, is to develop computationally efficient Bayesian inference methods to approximate, or draw samples from the posterior distributions. Variational inference (VI) provides a powerful tool for scaling Bayesian inference to complex models and big data. The basic idea of VI is to approximate the true distribution with a simpler distribution by minimizing the KL divergence, transforming the inference problem into an optimization problem, which is often then solved efficiently using stochastic optimization techniques (e.g., Hoffman et al., 2013; Kingma & Welling, 2013). However, the practical design and application of VI are still largely restricted by the requirement of using simple approximation families, as we explain in the sequel.
+
+Let $p ( z )$ be a distribution of interest, such as the posterior distribution in Bayesian inference. VI approximates $p ( z )$ with a simpler distribution $q ^ { * } ( z )$ found in a set $\mathcal { Q } = \{ q _ { \eta } ( z ) \}$ of distributions indexed by parameter $\eta$ by minimizing the KL divergence objective:
+
+$$
+\operatorname* { m i n } _ { \eta } \big \{ \mathrm { K L } ( q _ { \eta } | | p ) \equiv \mathbb { E } _ { z \sim q _ { \eta } } [ \log ( q _ { \eta } ( z ) / p ( z ) ) ] \big \} ,
+$$
+
+where we can get exact result $\boldsymbol { p } = \boldsymbol { q } ^ { * }$ if $\mathcal { Q }$ is chosen to be broad enough to actually include $p$ . In practice, however, $\mathcal { Q }$ should be chosen carefully to make the optimization in (1) computationally tractable; this casts two constraints on $\mathcal { Q }$ :
+
+1. A minimum requirement is that we should be able to sample from $q _ { \eta }$ efficiently, which allows us to make estimates and predictions based on $q _ { \eta }$ in placement of the more intractable $p$ . The samples from $q _ { \eta }$ can also be used to approximate the expectation $\mathbb { E } _ { q } [ \cdot ]$ in (1) during optimization. This means that there should exist some computable function $f ( \eta ; \xi )$ , called the inference network, which takes a random seed $\xi$ , whose distribution is denoted by $q _ { 0 }$ , and outputs a random variable $z = f ( \eta ; \xi )$ whose distribution is $q _ { \eta }$ .
+
+2. We should also be able to calculate the density $q _ { \eta } ( z )$ or it is derivative in order to optimize the KL divergence in (1). This, however, casts a much more restrictive condition, since it requires us to use only simple inference network $f ( \eta ; \xi )$ and input distributions $q _ { 0 }$ to ensure a tractable form for the density $q _ { \eta }$ of the output $z = f ( \eta ; \xi )$ .
+
+In fact, it is this requirement of calculating $q _ { \eta } ( z )$ that has been the major constraint for the design of state-of-the-art variational inference methods. The traditional $\mathrm { V I }$ methods are often limited to using simple mean field, or Gaussian-based distributions as $q _ { \eta }$ and do not perform well for approximating complex target distributions. There is a line of recent work on variational inference with rich approximation families (e.g., Rezende & Mohamed, 2015b; Tran et al., 2015; Ranganath et al., 2015, to name only a few), all based on handcrafting special inference networks to ensure the computational tractability of $q _ { \eta } ( z )$ while simultaneously obtaining high approximation accuracy. These approaches require substantial mathematical insights and research effects, and can be difficult to understand or use for practitioners without a strong research background in VI. Methods that allow us to use arbitrary inference networks without substantial constraints can significantly simplify the design and applications of VI methods, allowing practical users to focus more on choosing proposals that work best with their specific tasks.
+
+![](images/492f43da16371fc8172240c5ae93883a2e505491b54eb7915f5010a97f8cb46b.jpg)  
+Figure 1: Wild variational inference allows us to train general stochastic neural inference networks to learn to draw (approximate) samples from the target distributions, without restriction on the computational tractability of the density function of the neural inference networks.
+
+We use the term wild variational inference to refer to variants of variational methods working with general inference networks $f ( \eta , \xi )$ without tractability constraints on its output density $q _ { \eta } ( z )$ ; this should be distinguished with the black-box variational inference (Ranganath et al., 2014) which refers to methods that work for generic target distributions $p ( z )$ without significant model-by-model consideration (but still require to calculate the proposal density $q _ { \eta } ( z ) _ { , }$ ). Essentially, wild variational inference makes it possible to “learn to draw samples”, constructing black-box neural samplers for given distributions. This enables more adaptive and automatic design of efficient Bayesian inference procedures, replacing the hand-designed inference algorithms with more efficient ones that can improve their efficiency adaptively over time based on past tasks they performed.
+
+In this work, we discuss two methods for wild variational inference, both based on recent works that combine kernel techniques with Stein’s method (e.g., Liu & Wang, 2016; Liu et al., 2016). The first method, also discussed in Wang & Liu (2016), is based on iteratively adjusting parameter $\eta$ to make the random output $z = f ( \eta ; \xi )$ mimic a Stein variational gradient direction (SVGD) (Liu & Wang, 2016) that optimally decreases its KL divergence with the target distribution. The second method is based on minimizing a kernelized Stein discrepancy, which, unlike KL divergence, does not require to calculate density $q _ { \eta } ( z )$ for the optimization thanks to its special form.
+
+Another critical problem is to design good network architectures well suited for Bayesian inference. Ideally, the network design should leverage the information of the target distribution $p ( z )$ in a convenient way. One useful perspective is that we can view the existing MC/MCMC methods as (hand-designed) stochastic neural networks which can be used to construct native inference networks for given target distributions. On the other hand, using existing MC/MCMC methods as inference networks also allow us to adaptively adjust the hyper-parameters of these algorithms; this enables amortized inference which leverages the experience on past tasks to accelerate the Bayesian computation, providing a powerful approach for designing efficient algorithms in settings when a large number of similar tasks are needed.
+
+As an example, we leverage stochastic gradient Langevin dynamics (SGLD) (Welling & Teh, 2011) as the inference network, which can be treated as a special deep residential network (He et al., 2016), in which important gradient information $\nabla _ { z } \log { p ( z ) }$ is fed into each layer to allow efficient approximation for the target distribution $p ( z )$ . In our case, the network parameter $\eta$ are the step sizes of SGLD, and our method provides a way to adaptively improve the step sizes, providing speed-up on future tasks with similar structures. We show that the adaptively estimated step sizes significantly outperform the hand-designed schemes such as Adagrad.
+
+Related Works The idea of amortized inference (Gershman & Goodman, 2014) has been recently applied in various domains of probabilistic reasoning, including both amortized variational inference (e.g., Kingma & Welling, 2013; Rezende & Mohamed, 2015a) and date-driven designs of Monte Carlo based methods (e.g., Paige & Wood, 2016), to name only a few. Most of these methods, however, require to explicitly calculate $q _ { \eta } ( z )$ (or its gradient).
+
+One well exception is a very recent work (Ranganath et al., 2016) that also avoids calculating $q _ { \eta } ( z )$ and hence works for general inference networks; their method is based on a similar idea related to Stein discrepancy (Liu et al., 2016; Oates et al., 2017; Chwialkowski et al., 2016; Gorham & Mackey, 2015), for which we provide a more detailed discussion in Section 3.2.
+
+The auxiliary variational inference methods (e.g., Agakov & Barber, 2004) provide an alternative way when the variational distribution $q _ { \eta } ( z )$ can be represented as a hidden variable model. In particular, Salimans et al. (2015) used the auxiliary variational approach to leverage MCMC as a variational approximation. These approaches, however, still require to write down the likelihood function on the augmented spaces, and need to introduce an additional inference network related to the auxiliary variables.
+
+There is a large literature on traditional adaptive MCMC methods (e.g., Andrieu & Thoms, 2008; Roberts & Rosenthal, 2009) which can be used to adaptively adjust the proposal distribution of MCMC by exploiting the special theoretical properties of MCMC (e.g., by minimizing the autocorrelation). Our method is simpler, more generic, and works efficiently in practice thanks to the use of gradient-based back-propagation. Finally, connections between stochastic gradient descent and variational inference have been discussed and exploited in Mandt et al. (2016); Maclaurin et al. (2015).
+
+Outline Section 2 introduces background on Stein discrepancy and Stein variational gradient descent. Section 3 discusses two methods for wild variational inference. Section 4 discuss using stochastic gradient Langevin dynamics (SGLD) as the inference network. Empirical results are shown in Section 5.
+
+# 2 STEIN’S IDENTITY, STEIN DISCREPANCY, STEIN VARIATIONAL GRADIENT
+
+Stein’s identity Stein’s identity plays a fundamental role in our framework. Let $p ( z )$ be a positive differentiable density on $\mathbb { R } ^ { d }$ , and $\dot { \phi ( z ) } = [ \phi _ { 1 } ( z ) , \cdot \cdot \cdot , \phi _ { d } ( z ) ] ^ { \top }$ is a differentiable vector-valued function. Define $\begin{array} { r } { \nabla _ { z } \cdot \phi = \sum _ { i } \partial _ { z _ { i } } \phi } \end{array}$ . Stein’s identity is
+
+$$
+\mathbb { E } _ { z \sim p } [ \langle \nabla _ { z } \log p ( z ) , \phi ( z ) \rangle + \nabla _ { z } \cdot \phi ( z ) ] = \int _ { \mathcal { X } } \nabla _ { z } \cdot ( p ( z ) \phi ( z ) ) d x = 0 ,
+$$
+
+which holds once $p ( z ) \phi ( z )$ vanishes on the boundary of $\mathcal { X }$ by integration by parts or Stokes’ theorem; It is useful to rewrite Stein’s identity in a more compact way:
+
+$$
+\begin{array} { r } { \mathbb { E } _ { z \sim p } [ \mathcal { T } _ { p } \phi ( z ) ] = 0 , \quad \mathrm { ~ w i t h ~ } \quad \mathcal { T } _ { p } \phi \overset { d e f } { = } \langle \nabla _ { z } \log p , \phi \rangle + \nabla _ { z } \cdot \phi , } \end{array}
+$$
+
+where $\mathcal { T } _ { p }$ is called a Stein operator, which acts on function $\phi$ and returns a zero-mean function $\mathcal { T } _ { p } \phi ( z )$ under $z \sim p$ . A key computational advantage of Stein’s identity and Stein operator is that they depend on $p$ only through the derivative of the log-density $\nabla _ { z } \log { p ( z ) }$ , which does not depend on the cumbersome normalization constant of $p$ , that is, when $p ( z ) = \bar { p } ( z ) / Z$ , we have $\nabla _ { z } \log { p ( z ) } = \nabla _ { z } \log { \bar { p } ( z ) }$ , independent of the normalization constant $Z$ . This property makes Stein’s identity a powerful practical tool for handling unnormalized distributions widely appeared in machine learning and statistics.
+
+Stein Discrepancy Although Stein’s identity ensures that $\mathcal { T } _ { p } \phi$ has zero expectation under $p$ , its expectation is generally non-zero under a different distribution $q$ . Instead, for $p \neq q$ , there must exist a $\phi$ which distinguishes $p$ and $q$ in the sense that $\mathbb { E } _ { z \sim q } [ \mathcal { T } _ { p } \phi ( z ) ] \neq 0$ . Stein discrepancy leverages this fact to measure the difference between $p$ and $q$ by considering the “maximum violation of Stein’s identity” for $\phi$ in certain function set $\mathcal { F }$ :
+
+$$
+\mathbb { D } ( q | | p ) = \operatorname* { m a x } _ { \phi \in \mathcal { F } } \big \{ \mathbb { E } _ { z \sim q } [ \mathcal { T } _ { p } \phi ( z ) ] \big \} ,
+$$
+
+where $\mathcal { F }$ is the set of functions $\phi$ that we optimize over, and decides both the discriminative power and computational tractability of Stein discrepancy. Kernelized Stein discrepancy (KSD) is a special
+
+Stein discrepancy that takes $\mathcal { F }$ to be the unit ball of vector-valued reproducing kernel Hilbert spaces (RKHS), that is,
+
+$$
+\mathcal { F } = \{ \phi \in \mathcal { H } ^ { d } : | | \phi | | _ { \mathcal { H } ^ { d } } \leq 1 \} ,
+$$
+
+where $\mathcal { H }$ is a real-valued RKHS with kernel $k ( z , z ^ { \prime } )$ . This choice of $\mathcal { F }$ makes it possible to get a closed form solution for the optimization in (4) (Liu et al., 2016; Chwialkowski et al., 2016; Oates et al., 2017):
+
+$$
+\begin{array} { r l } { \mathbb { D } ( q | | p ) = \underset { \phi \in \mathcal { H } ^ { d } } { \operatorname* { m a x } } \big \lbrace \mathbb { E } _ { z \sim q } [ T _ { p } \phi ( z ) ] , } & { \quad s . t . \quad | | \phi | | _ { \mathcal { H } ^ { d } } \leq 1 \big \rbrace , } \\ { = \sqrt { \mathbb { E } _ { z , z ^ { \prime } \sim q } [ \kappa _ { p } ( z , z ^ { \prime } ) ] } , } \end{array}
+$$
+
+where $\kappa _ { p } \big ( z , z ^ { \prime } \big )$ is a positive definite kernel obtained by applying Stein operator on $k ( z , z ^ { \prime } )$ twice:
+
+$$
+\begin{array} { r l } & { \kappa _ { p } ( z , z ^ { \prime } ) = { \mathcal { T } } _ { p } ^ { z ^ { \prime } } ( { \mathcal { T } } _ { p } ^ { z } \otimes k ( z , z ^ { \prime } ) ) , } \\ & { \qquad = s _ { p } ( z ) s _ { p } ( z ^ { \prime } ) k ( z , z ^ { \prime } ) + s _ { p } ( z ) { \nabla _ { z ^ { \prime } } k ( z , z ^ { \prime } ) } + s _ { p } ( z ^ { \prime } ) { \nabla _ { z } k ( z , z ^ { \prime } ) } + { \nabla _ { z } } \cdot ( { \nabla _ { z ^ { \prime } } k ( z , z ^ { \prime } ) } ) , } \end{array}
+$$
+
+where $\pmb { \mathscr { s } } _ { p } ( z ) = \nabla _ { z } \log p ( z )$ and $\mathcal { T } _ { p } ^ { z }$ and $\mathcal { T } _ { p } ^ { z }$ denote the Stein operator when treating $k ( z , z ^ { \prime } )$ as a function of $z$ and $z ^ { \prime }$ , respectively; here we defined $\begin{array} { r } { T _ { p } ^ { z } \otimes k ( z , z ^ { \prime } ) = \nabla _ { x } \log p ( x ) k ( z , z ^ { \prime } ) + \nabla _ { x } k ( z , z ^ { \prime } ) } \end{array}$ which returns a $d \times 1$ vector-valued function. It can be shown that $\mathbb { D } ( q | | p ) = 0$ if and only if $q = p$ when $k ( z , z ^ { \prime } )$ is strictly positive definite in a proper sense (Liu et al., 2016; Chwialkowski et al., 2016). $\mathbb { D } ( q \mid \mid p )$ can treated as a variant of maximum mean discrepancy equipped with kernel $\kappa _ { p } \big ( z , z ^ { \prime } \big )$ which depends on $p$ (which makes $\mathbb { D } ( q | | p )$ asymmetric on $q$ and $p$ ).
+
+The form of KSD in (6) allows us to estimate the discrepancy between a set of sample $\left\{ z _ { i } \right\}$ (e.g., drawn from $q$ ) and a distribution $p$ specified by $\nabla _ { z } \log { p ( z ) }$ ,
+
+$$
+\widehat { \mathbb { D } } _ { u } ^ { 2 } ( \{ z _ { i } \} \mid | p ) = \frac { 1 } { n ( n - 1 ) } \sum _ { i \neq j } [ \kappa _ { p } ( z _ { i } , z _ { j } ) ] , \qquad \widehat { \mathbb { D } } _ { v } ^ { 2 } ( \{ z _ { i } \} \mid | p ) = \frac { 1 } { n ^ { 2 } } \sum _ { i , j } [ \kappa _ { p } ( z _ { i } , z _ { j } ) ] ,
+$$
+
+where $\hat { \mathbb { D } } _ { u } ^ { 2 } ( q | | \operatorname { \varepsilon } p )$ provides an unbiased estimator (hence called a $U$ -statistic) for $\mathbb { D } ^ { 2 } ( q \mid | \ p )$ , and $\hat { \mathbb { D } } _ { v } ^ { 2 } ( q \mid | \ p )$ , called $V$ -statistic, provides a biased estimator but is guaranteed to be always nonnegative: $\hat { \mathbb { D } } _ { v } ^ { 2 } \big ( \{ z _ { i } \} \mid \mid p \big ) \ge 0$ .
+
+Stein Variational Gradient Descent (SVGD) Stein operator and Stein discrepancy have a close connection with KL divergence, which is exploited in Liu $\&$ Wang (2016) to provide a general purpose deterministic approximate sampling method. Assume that $\{ z _ { i } \} _ { i = 1 } ^ { n }$ is a sample (or a set of particles) drawn from $q$ , and we want to update $\{ z _ { i } \} _ { i = 1 } ^ { n }$ to make it “move closer” to the target distribution $p$ to improve the approximation quality. We consider updates of form
+
+$$
+z _ { i } \gets z _ { i } + \epsilon \phi ^ { * } ( z _ { i } ) , \quad \forall i = 1 , \dots , n ,
+$$
+
+where $\phi ^ { * }$ is a perturbation direction, or velocity field, chosen to maximumly decrease the KL divergence between the distribution of updated particles and the target distribution, in the sense that
+
+$$
+\phi ^ { * } = \underset { \phi \in \mathcal { F } } { \arg \operatorname* { m a x } } \bigg \{ - \frac { d } { d \epsilon } \mathrm { K L } ( q _ { [ \epsilon \phi ] } \left| \right| p ) \big | _ { \epsilon = 0 } \bigg \} ,
+$$
+
+where $q _ { [ \epsilon \phi ] }$ denotes the density of the updated particle $z ^ { \prime } = z + \epsilon \phi ( z )$ when the density of the original particle $z$ is $q$ , and $\mathcal { F }$ is the set of perturbation directions that we optimize over. A key observation (Liu & Wang, 2016) is that the optimization in (11) is in fact equivalent to the optimization for KSD in (4); we have
+
+$$
+- \frac { d } { d \epsilon } \mathrm { K L } ( q _ { [ \epsilon \phi ] } \left| \right| p ) \big | _ { \epsilon = 0 } = \mathbb { E } _ { z \sim q } [ \mathcal { T } _ { p } \phi ( z ) ] ,
+$$
+
+that is, the Stein operator transforms the perturbation $\phi$ on the random variable (the particles) to the change of the KL divergence. Taking $\mathcal { F }$ to be unit ball of $\mathcal { H } ^ { d }$ as in (5), the optimal solution $\phi ^ { * }$ of (11) equals that of (6), which is shown to be (e.g., Liu et al., 2016)
+
+$$
+\phi ^ { * } ( z ^ { \prime } ) \propto \mathbb { E } _ { z \sim q } [ \mathcal { T } _ { p } ^ { z } k ( z , z ^ { \prime } ) ] = \mathbb { E } _ { z \sim q } [ \nabla _ { z } \log p ( z ) k ( z , z ^ { \prime } ) + \nabla _ { z } k ( z , z ^ { \prime } ) ] .
+$$
+
+# Algorithm 1 Amortized SVGD and KSD Minimization for Wild Variational Inference
+
+for iteration t do
+
+1. Draw random $\{ \xi _ { i } \} _ { i = 1 } ^ { n }$ , calculate $z _ { i } = f ( \eta ; \xi _ { i } )$ , and the Stein variational gradient $\Delta z _ { i }$ in (13). 2. Update parameter $\eta$ using (14) or (15) for amortized SVGD, or (17) for KSD minimization. end for
+
+By approximating the expectation under $q$ with the empirical mean of the current particles $\{ z _ { i } \} _ { i = 1 } ^ { n }$ , SVGD admits a simple form of update that iteratively moves the particles towards the target distribution,
+
+$$
+\begin{array} { r l } & { \qquad z _ { i } \gets z _ { i } + \epsilon \Delta z _ { i } , \quad \forall i = 1 , \ldots , n , } \\ & { \qquad \Delta z _ { i } = \hat { \mathbb { E } } _ { z \in \{ z _ { i } \} _ { i = 1 } ^ { n } } [ \nabla _ { z } \log p ( z ) k ( z , z _ { i } ) + \nabla _ { z } k ( z , z _ { i } ) ] , } \end{array}
+$$
+
+where $\begin{array} { r } { \hat { \mathbb { E } } _ { z \sim \{ z _ { i } \} _ { i = 1 } ^ { n } } [ f ( z ) ] = \sum _ { i } f ( z _ { i } ) / n } \end{array}$ . The two terms in $\Delta z _ { i }$ play two different roles: the term with the gradient $\nabla _ { z } \log { p ( z ) }$ drives the particles towards the high probability regions of $p ( z )$ , while the term with $\nabla _ { z } k ( z , z _ { i } )$ serves as a repulsive force to encourage diversity; to see this, consider a stationary kernel $k ( z , z ^ { \prime } ) = k ( z - z ^ { \prime } )$ , then the second term reduces to $\hat { \mathbb { E } } _ { z } \nabla _ { z } k ( z , z _ { i } ) =$ $- \hat { \mathbb { E } } _ { z } \nabla _ { z _ { i } } k ( z , z _ { i } )$ , which can be treated as the negative gradient for minimizing the average similarity $\hat { \mathbb { E } } _ { z } k ( z , z _ { i } )$ in terms of $z _ { i }$ .
+
+It is easy to see from (13) that $\Delta z _ { i }$ reduces to the typical gradient $\nabla _ { z } \log { p ( z _ { i } ) }$ when there is only a single particle $( n = 1$ ) and $\nabla _ { z } k ( z , z _ { i } )$ when $z = z _ { i }$ , in which case SVGD reduces to the standard gradient ascent for maximizing $\log p ( z )$ (i.e., maximum a posteriori (MAP)).
+
+# 3 TWO METHODS FOR WILD VARIATIONAL INFERENCE
+
+Since the direct parametric optimization of the KL divergence (1) requires calculating $q _ { \eta } ( z )$ , there are two essential ways to avoid calculating $q _ { \eta } ( z )$ : either using alternative (approximate) optimization approaches, or using different divergence objective functions. We discuss two possible approaches in this work: one based on “amortizing SVGD” (Wang & Liu, 2016) which trains the inference network $f ( \eta , \xi )$ so that its output mimic the SVGD dynamics in order to decrease the KL divergence; another based on minimizing the KSD objective (9) which does not require to evaluate $q ( z )$ thanks to its special form.
+
+# 3.1 AMORTIZED SVGD
+
+SVGD provides an optimal updating direction to iteratively move a set of particles $\left\{ z _ { i } \right\}$ towards the target distribution $p ( z )$ . We can leverage it to train an inference network $f ( \eta ; \xi )$ by iteratively adjusting $\eta$ so that the output of $f ( \eta ; \xi )$ changes along the Stein variational gradient direction in order to maximumly decrease its KL divergence with the target distribution. By doing this, we “amortize” SVGD into a neural network, which allows us to leverage the past experience to adaptively improve the computational efficiency and generalize to new tasks with similar structures. Amortized SVGD is also presented in Wang $\&$ Liu (2016); here we present some additional discussion.
+
+To be specific, assume $\{ \xi _ { i } \}$ are drawn from $q _ { 0 }$ and $z _ { i } = f ( \eta ; \xi _ { i } )$ the corresponding random output based on the current estimation of $\eta$ . We want to adjust $\eta$ so that $z _ { i }$ changes along the Stein variational gradient direction $\Delta z _ { i }$ in (13) so as to maximumly decrease the KL divergence with target distribution. This can be done by updating $\eta$ via
+
+$$
+\eta \gets \underset { \eta } { \arg \operatorname* { m i n } } \sum _ { i = 1 } ^ { n } | | f ( \eta ; \xi _ { i } ) - z _ { i } - \epsilon \Delta z _ { i } | | _ { 2 } ^ { 2 } .
+$$
+
+Essentially, this projects the non-parametric perturbation direction $\Delta z _ { i }$ to the change of the finite dimensional network parameter $\eta$ . If we take the step size $\epsilon$ to be small, then the updated $\eta$ by (14) should be very close to the old value, and a single step of gradient descent of (14) can provide a
+
+good approximation for (14). This gives a simpler update rule:
+
+$$
+\eta  \eta + \epsilon \sum _ { i } \partial _ { \eta } f ( \eta ; \xi _ { i } ) \Delta z _ { i } ,
+$$
+
+which can be intuitively interpreted as a form of chain rule that back-propagates the SVGD gradient to the network parameter $\eta$ . In fact, when we have only one particle, (15) reduces to the standard gradient ascent for $\operatorname* { m a x } _ { \eta } \log p ( f ( \eta ; ~ \xi ) )$ , in which $f _ { \eta }$ is trained to “learn to optimize” (e.g., Andrychowicz et al., 2016), instead of “learn to sample” $\dot { p ( z ) }$ . Importantly, as we have more than one particles, the repulsive term $\nabla _ { z } k ( z , z _ { i } )$ in $\Delta z _ { i }$ becomes active, and enforces an amount of diversity on the network output that is consistent with the variation in $p ( z )$ . The full algorithm is summarized in Algorithm 1.
+
+Amortized SVGD can be treated as minimizing the KL divergence using a rather special algorithm: it leverages the non-parametric SVGD which can be treated as approximately solving the infinite dimensional optimization ${ \mathrm { m i n } } _ { q } \operatorname { K L } ( q | | p )$ without explicitly assuming a parametric form on $q$ , and iteratively projecting the non-parametric update back to the finite dimensional parameter space of $\eta$ . It is an interesting direction to extend this idea to “amortize” other MC/MCMC-based inference algorithms. For example, given a MCMC with transition probability $T ( z ^ { \prime } | z )$ whose stationary distribution is $p ( z )$ , we may adjust $\eta$ to make the network output move towards the updated values $z ^ { \prime }$ drawn from the transition probability $T ( z ^ { \prime } | z )$ . The advantage of using SVGD is that it provides a deterministic gradient direction which we can back-propagate conveniently and is particle efficient in that it reduces to “learning to optimize” with a single particle. We have been using the simple $L ^ { 2 }$ loss in (14) mainly for convenience; it is possible to use other two-sample discrepancy measures such as maximum mean discrepancy.
+
+# 3.2 KSD VARIATIONAL INFERENCE
+
+Amortized SVGD attends to minimize the KL divergence objective, but can not be interpreted as a typical finite dimensional optimization on parameter $\eta$ . Here we provide an alternative method based on directly minimizing the kernelized Stein discrepancy (KSD) objective, for which, thanks to its special form, the typical gradient-based optimization can be performed without needing to estimate $q ( z )$ explicitly.
+
+To be specific, take $q _ { \eta }$ to be the density of the random output $z = f ( \eta ; \xi )$ when $\xi \sim q _ { 0 }$ , and we want to find $\eta$ to minimize $\mathbb { D } ( q _ { \eta } \parallel p )$ . Assuming $\{ \xi _ { i } \}$ is i.i.d. drawn from $q _ { 0 }$ , we can approximate $\mathbb { D } ^ { 2 } ( q _ { \eta } | | p )$ unbiasedly with a U-statistics:
+
+$$
+\mathbb { D } ^ { 2 } ( q _ { \eta } | | p ) \approx \frac { 1 } { n ( n - 1 ) } \sum _ { i \neq j } \kappa _ { p } ( f ( \eta ; \xi _ { i } ) , f ( \eta ; \xi _ { j } ) ) ,
+$$
+
+for which a standard gradient descent can be derived for optimizing $\eta$ :
+
+$$
+\eta  \eta - \epsilon \frac { 2 } { n ( n - 1 ) } \sum _ { i \neq j } \partial _ { \eta } f ( \eta ; \xi _ { i } ) \nabla _ { z _ { i } } \kappa _ { p } ( z _ { i } , z _ { j } ) , \quad \mathrm { ~ w h e r e ~ } \quad z _ { i } = f ( \eta ; \xi _ { i } ) .
+$$
+
+This enables a wild variational inference method based on directly minimizing $\eta$ with standard (stochastic) gradient descent. See Algorithm 1. Note that (17) is similar to (15) in form, but replaces ∆zi with a ∆˜ zi ∝ − Pj : i6=j $\begin{array} { r } { \tilde { \Delta } z _ { i } \propto - \sum _ { j : i \neq j } \nabla _ { z _ { i } } \bar { \kappa } _ { p } ( z _ { i } , z _ { j } ) } \end{array}$ . It is also possible to use the $V$ -statistic in (9), but we find that the $U$ -statistic performs much better in practice, possibly because of its unbiasedness property.
+
+Minimizing KSD can be viewed as minimizing a constrastive divergence objective function. To see this, recall that $q _ { [ \epsilon \phi ] }$ denotes the density of $z ^ { \prime } = z + \epsilon \phi ( z )$ when $z \sim q$ . Combining (11) and (6), we can show that
+
+$$
+\mathbb { D } ^ { 2 } ( q | | p ) \approx \frac { 1 } { \epsilon } ( \mathrm { K L } ( q | | p ) - \mathrm { K L } ( q _ { [ \epsilon \phi ] } | | p ) ) .
+$$
+
+That is, KSD measures the amount of decrease of $\mathrm { K L }$ divergence when we update the particles along the optimal SVGD perturbation direction $\phi$ given by (11). If $q = p$ , then the decrease of KL
+
+divergence equals zero and $\mathbb { D } ^ { 2 } ( q | | p )$ equals zero. In fact, as shown in Liu & Wang (2016) KSD can be explicitly represented as the magnitude of a functional gradient of KL divergence:
+
+$$
+\mathbb { D } ( q \parallel p ) = \biggl \| \frac { d } { d \phi } \mathrm { K L } ( q _ { [ \phi ] } \parallel p ) \bigr | _ { \phi = 0 } \biggl | \biggl | _ { \mathcal { H } ^ { d } } ,
+$$
+
+where $q _ { [ \phi ] }$ is the density of $z = z + \phi ( z )$ when $z \sim q$ , and $\textstyle { \frac { d } { d \phi } } F ( \phi )$ denotes the functional gradient of functional $F ( \phi )$ w.r.t. $\phi$ defined in RKHS $\mathcal { H } ^ { d }$ , and $\begin{array} { r } { \frac { d } { d \phi } F ( { \dot { \phi } } ) } \end{array}$ is also an element in $\mathcal { H } ^ { d }$ . Therefore, KSD variational inference can be treated as explicitly minimizing the magnitude of the gradient of KL divergence, in contract with amortized SVGD which attends to minimize the KL divergence objective itself.
+
+This idea is also similar to the contrastive divergence used for learning restricted Boltzmann machine (RBM) (Hinton, 2002) (which, however, optimizes $p$ with fixed $q$ ). It is possible to extend this approach by replacing $z ^ { \prime } = z + \epsilon \phi ( z )$ with other transforms, such as these given by a transition probability of a Markov chain whose stationary distribution is $p$ . In fact, according the so called generator method for constructing Stein operator (Barbour, 1988), any generator of a Markov process defines a Stein operator that can be used to define a corresponding Stein discrepancy.
+
+This idea is related to a very recent work by Ranganath et al. (2016), which is based on directly minimizing the variational form of Stein discrepancy in (4); Ranganath et al. (2016) assumes $\mathcal { F }$ consists of a neural network $\phi _ { \tau } ( z )$ parametrized by $\tau$ , and find $\eta$ by solving the following min-max problem:
+
+$$
+\operatorname* { m i n } _ { \eta } \operatorname* { m a x } _ { \tau } \mathbb { E } _ { z \sim q } [ \mathcal { T } _ { p } \phi _ { \tau } ( z ) ] .
+$$
+
+In contrast, our method leverages the closed form solution by taking $\mathcal { F }$ to be an RKHS and hence obtains an explicit optimization problem, instead of a min-max problem that can be computationally more expensive, or have difficulty in achieving convergence.
+
+Because $\kappa _ { p } ( \boldsymbol { x } , \boldsymbol { x } ^ { \prime } )$ (defined in (8)) depends on the derivative $\nabla _ { x } \log p ( x )$ of the target distribution, the gradient in (17) depends on the Hessian matrix $\nabla _ { x } ^ { 2 } \log p ( x )$ and is hence less convenient to implement compared with amortized SVGD (the method by Ranganath et al. (2016) also has the same problem). However, this problem can be alleviated using automatic differentiation tools, which be used to directly take the derivative of the objective in (16) without manually deriving its derivatives.
+
+# 4 LANGEVIN INFERENCE NETWORK
+
+With wild variational inference, we can choose more complex inference network structures to obtain better approximation accuracy. Ideally, the best network structure should leverage the special properties of the target distribution $p ( z )$ in a convenient way. One way to achieve this by viewing existing MC/MCMC methods as inference networks with hand-designed (and hence potentially suboptimal) parameters, but good architectures that take the information of the target distribution $p ( z )$ into account. By applying wild variational inference on networks constructed based on existing MCMC methods, we effectively provide an hyper-parameter optimization for these existing methods. This allows us to fully optimize the potential of existing Bayesian inference methods, significantly improving the result with less computation cost, and decreasing the need for hyper-parameter tuning by human experts. This is particularly useful when we need to solve a large number of similar tasks, where the computation cost spent on optimizing the hyper-parameters can significantly improve the performance on the future tasks.
+
+Stochastic Gradient Langevin Dynamics We first take the original stochastic gradient Langevin dynamics (SGLD) algorithm (Welling & Teh, 2011) as an example. SGLD starts with a random initialization $z _ { \mathrm { 0 } }$ , and perform iterative update of form
+
+$$
+z ^ { t + 1 } \gets z ^ { t } + \eta ^ { t } \odot \nabla _ { z } \log \hat { p } ( z ^ { t } ; \mathbb { M } ^ { t } ) + \sqrt { 2 \eta ^ { t } } \odot \xi ^ { t } , \quad \forall t = 1 , \cdot \cdot \cdot T ,
+$$
+
+where $\log \hat { p } ( z ^ { t } ; \ \mathbb { M } ^ { t } )$ denotes an approximation of $\log p ( z ^ { t } )$ based on, e.g., a random mini-batch $\mathbb { M } ^ { t }$ of observed data at $t$ -th iteration, and $\xi ^ { t }$ is a standard Gaussian random vector of the same size as $z$ , and $\eta ^ { t }$ denotes a (vector) step-size at $t$ -th iteration; here “ $\odot$ ” denotes element-wise product. When running SGLD for $T$ iterations, we can treat $z ^ { T }$ as the output of a $T$ -layer neural network parametrized by the collection of step sizes $\eta = \{ \eta ^ { t } \} _ { t = 1 } ^ { T }$ , whose random inputs include the random initialization $z _ { \mathrm { 0 } }$ , the mini-batch $\mathbb { M } ^ { t }$ and Gaussian noise $\xi ^ { t }$ at each iteration $t$ . We can see that this defines a rather complex network structure with several different types of random inputs $( z ^ { 0 } , \mathbb { M } ^ { t }$ and $\boldsymbol { \xi } ^ { t }$ ). This makes it intractable to explicitly calculate the density of $z ^ { T }$ and traditional variational inference methods can not be applied directly. But wild variational inference can still allow us to adaptively improve the optimal step-size $\eta$ in this case.
+
+![](images/d01a7e1c35323e43b5217ad65d7e281f4bd1b1cefac515f6b3a5b589310d9d9a.jpg)  
+Figure 2: Results on a 1D Gaussian mixture when training the step sizes of SGLD with $T = 2 0$ iterations. The target distribution $p ( x )$ is shown by the red dashed line. (a) The distribution of the initialization $z _ { 0 }$ of SGLD (the green line), visualized by kernel density estimator. (b)-(d) The distribution of the final output $z ^ { T }$ (green line) given by different types of step sizes, visualized by kernel density estimator.
+
+General Langevin Networks Based on the original formula of SGLD, we proposed a more general langevin network structure, and each layer of the network has a form
+
+$$
+\begin{array} { r l r } & { z ^ { t + 1 } \gets A ^ { t } z ^ { t } + h ( B ^ { t } B ^ { t } ^ { \top } \nabla _ { z } \log \hat { p } ( z ^ { t } ; \mathbb { M } ^ { t } ) + B ^ { t } \xi ^ { t } + D ^ { t } ) , \quad } & { \forall t = 1 , \cdots T , } \end{array}
+$$
+
+where $A ^ { t } , B ^ { t }$ and $D ^ { t }$ are network parameters at $t$ -th iteration(whose size is $d \times d$ , and $d$ is the size of $z ^ { t }$ ), and $h ( \cdot )$ denotes a smooth element-wise non-linearity function; here $\xi ^ { t }$ is still a standard gaussian random vector with the same size as $z$ . With this more complex network, we can use fewer layers to construct more powerful back-box samplers.
+
+# 5 EMPIRICAL RESULTS
+
+# 5.1 SGLD INFERENCE NETWORK
+
+We first test our algorithm with SGLD inference network with (18) formula on both a toy Gaussian mixture model and a Bayesian logistic regression example. We find that we can adaptively learn step sizes that significantly outperform the existing hand-designed step size schemes, and hence save computational cost in the testing phase. In particular, we compare with the following step size schemes, for all of which we report the best results (testing accuracy in Figure 3(a); testing likelihood in Figure 3(b)) among a range of hyper-parameters:
+
+1. Constant Step Size. We select a best constant step size in $\{ 1 , 2 , 2 ^ { 3 } , \dots , 2 ^ { 2 9 } \} \times 1 0 ^ { - 6 }$ .
+
+2. Power Decay Step Size. We consider $\epsilon ^ { t } ~ = ~ 1 0 ^ { a } ~ \times ~ ( b + t ) ^ { - \gamma }$ where $\gamma \ = \ 0 . 5 5$ , $a \in$ $\{ - 6 , - 5 , \ldots , 1 , 2 \}$ , $b \in \{ 0 , 1 , \ldots , 9 \}$ .
+
+3. Adagrad, Rmsprop, Adadelta, all with the master step size selected in $\{ 1 , 2 , 2 ^ { 3 } , \dots , 2 ^ { 2 9 } \} \times 1 0 ^ { - 6 }$ , with the other parameters chosen by default values.
+
+Gaussian Mixture We start with a simple 1D Gaussian mixture example shown in Figure 2 where the target distribution $p ( z )$ is shown by the red dashed curve. We use amortized SVGD and KSD to optimize the step size parameter of the Langevin inference network in (18) with $T = 2 0$ layers (i.e., SGLD with $T = 2 0$ iterations), with an initial $z _ { \mathrm { 0 } }$ drawn from a $q _ { 0 }$ far away from the target distribution (see the green curve in Figure 2(a)); this makes it critical to choose a proper step size to achieve close approximation within $T = 2 0$ iterations. We find that amortized SVGD and KSD allow us to achieve good performance with 20 steps of SGLD updates (Figure 2(b)-(c)), while the result of the best constant step size and power decay step-size are much worse (Figure 2(d)-(e)).
+
+![](images/858102adb7f3c954e9a9dd7b03a65ea02c4fcccf9767ec7a02edd22091c97062.jpg)  
+Figure 3: The testing accuracy (a) and testing likelihood (b) when training Langevin inference network with $T \in \{ 1 0 , \bar { 5 } 0 , 1 0 0 \}$ layers, respectively. The results reported here are the performance of the final result $z ^ { T }$ outputted by the last layer of the network. We find that both amortized SVGD and KSD minimization (with $\mathrm { U }$ -statistics) outperform all the hand-designed learning rates. Results averaged on 100 random trails.
+
+Bayesian Logistic Regression We consider Bayesian logistic regression for binary classification using the same setting as Gershman et al. (2012), which assigns the regression weights $w$ with a Gaussian prior $p _ { 0 } ( w | \bar { \alpha } ) = \mathcal { N } ( w , \alpha ^ { - 1 } )$ and $p _ { 0 } ( \alpha ) = G a m m a ( \alpha , 1 , 0 . 0 1 )$ . The inference is applied on the posterior of $z = [ w , \log \alpha ]$ . We test this model on the binary Covertype dataset1 with 581,012 data points and 54 features.
+
+To demonstrate that our estimated learning rate can work well on new datasets never seen by the algorithm. We partition the dataset into mini-datasets of size 50, 000, and use $8 0 \%$ of them for training and $2 0 \%$ for testing. We adapt our amortized SVGD/KSD to train on the whole population of the training mini-datasets by randomly selecting a mini-dataset at each iteration of Algorithm 1, and evaluate the performance of the estimated step sizes on the remaining $2 0 \%$ testing mini-datasets.
+
+Figure 3 reports the testing accuracy and likelihood on the $2 0 \%$ testing mini-datasets when we train the Langevin network with $T = 1 0 , 5 0 , 1 0 0$ layers, respectively. We find that our methods outperform all the hand-designed learning rates, and allow us to get performance closer to the fully converged SGLD and SVGD with a small number $T$ of iterations.
+
+Figure 4 shows the testing accuracy and testing likelihood of all the intermediate results when training Langevin network with $T = 1 0 0$ layers. It is interesting to observe that amortized SVGD and KSD learn rather different behavior: KSD tends to increase the performance quickly at the first few iterations but saturate quickly, while amortized SVGD tends to increase slowly in the beginning and boost the performance quickly in the last few iterations. Note that both algorithms are set up to optimize the performance of the last layers, while need to decide how to make progress on the intermediate layers to achieve the best final performance.
+
+# 5.2 GENERAL LANGEVIN INFERENCE NETWORK
+
+We further test our algorithm with general Langevin inference network. We firstly construct one single layer general Langevin network to approach the posterior of Bayesian logistic regression parameters and we can achieve $7 4 . 5 8 \%$ average accuracy and $- 0 . 5 2 1 6$ average testing log-likelihood in 100 repeat experiments. This result proves the proposed general Langevin Inference Network is quite competitive and worth to explore. Moreover, we use it as a black-box sampler to approach more complicate Gaussian Mixture distributions.
+
+Gaussian Mixture We consider 10 components Gaussian Mixture Models with mean and covariance matrix of each component randomly drawed from a uniform distribution, and we test our methods on different dimensions models.
+
+We construct 6 layers of general Langevin networks as a black-box sampler, and our proposed two methods to train the black-box sampler to approximate the target distribution. Figure 5 shows our results on 50 dimension Gaussian Mixture case and figure 6 shows results of different dimensions of Gaussian Mixture. From the figures we can know that our proposed sampling structure is quite competive comparing with NUT sampler(Hoffman & Gelman, 2014), and these two variational inference methods can both train a good black-box sampler.
+
+![](images/b51f406093bed295d5f6b9f4bff9d74ab2e413a98fae5aae64a7c4df31ea9c26.jpg)  
+Figure 4: The testing accuracy (a) and testing likelihood (b) of the outputs of the intermediate layers when training the Langevin network with $\bar { T } = 1 0 0$ layers. Note that both amortized SVGD and KSD minimization target to optimize the performance of the last layer, but need to optimize the progress of the intermediate steps in order to achieve the best final results.
+
+![](images/11ffb85315b5278fdeac6e9921e4cc43945ee3da66dcc44852474a305675e7ab.jpg)  
+Figure 5: Comparation between our methods and NUTS on 50 dimension Gaussian Mixture. (a)-(c) show the mean square errors when using different number particles to estimate expectation $\mathbb { E } ( h ( x ) )$ for $h ( x ) = x$ , $\bar { x ^ { 2 } }$ , and $c o s ( x + b )$ ; for $\cos ( \omega x + b )$ , we random draw $\omega \sim \mathcal { N } ( 0 , 1 )$ and $b \sim$ Uniform $( [ 0 , 2 \pi ] )$ and report the average MSE over 10 random draws of and b.
+
+![](images/08bb781eebe5730a7ad456b1b4ed41bb9785a9a7f86452204c07c4983560432e.jpg)  
+Figure 6: Comparation between our methods and NUTS For different dimension Gaussian Mixture. (a)-(c) show the mean square errors when using different number particles to estimate expectation $\mathbb { E } ( h ( x ) )$ for $h ( x ) = x ,$ , $\overline { { x ^ { 2 } } }$ , and $c o s ( x + b )$ ; for $c o s ( \omega x + b )$ , we random draw $\omega \sim \mathcal { N } ( 0 , 1 )$ and $\boldsymbol { b } \sim \operatorname { U n i f o r m } ( [ 0 , 2 \pi ] )$ and report the average MSE over 10 random draws of and b.
+
+# 6 CONCLUSION
+
+We consider two methods for wild variational inference that allows us to train general inference networks with intractable density functions, and apply it to adaptively estimate step sizes of stochastic gradient Langevin dynamics. More studies are needed to develop better methods, more applications and theoretical understandings for wild variational inference, and we hope that the two methods we discussed in the paper can motivate more ideas and studies in the field.
+
+# REFERENCES
+
+Agakov, Felix V and Barber, David. An auxiliary variational method. In International Conference on Neural Information Processing, pp. 561–566. Springer, 2004.   
+Andrieu, Christophe and Thoms, Johannes. A tutorial on adaptive mcmc. Statistics and Computing, 18(4): 343–373, 2008.   
+Andrychowicz, Marcin, Denil, Misha, Gomez, Sergio, Hoffman, Matthew W, Pfau, David, Schaul, Tom, and de Freitas, Nando. Learning to learn by gradient descent by gradient descent. arXiv preprint arXiv:1606.04474, 2016.   
+Barbour, Andrew D. Stein’s method and poisson process convergence. Journal of Applied Probability, pp. 175–184, 1988.   
+Chwialkowski, Kacper, Strathmann, Heiko, and Gretton, Arthur. A kernel test of goodness of fit. In Proceedings of the International Conference on Machine Learning (ICML), 2016.   
+Gershman, Samuel, Hoffman, Matt, and Blei, David. Nonparametric variational inference. In Proceedings of the International Conference on Machine Learning (ICML), 2012.   
+Gershman, Samuel J and Goodman, Noah D. Amortized inference in probabilistic reasoning. In Proceedings of the 36th Annual Conference of the Cognitive Science Society, 2014.   
+Gorham, Jack and Mackey, Lester. Measuring sample quality with Stein’s method. In Advances in Neural Information Processing Systems (NIPS), pp. 226–234, 2015.   
+He, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Deep residual learning for image recognition. In CVPR, 2016.   
+Hinton, Geoffrey E. Training products of experts by minimizing contrastive divergence. Neural computation, 14(8):1771–1800, 2002.   
+Hoffman, Matthew D and Gelman, Andrew. The no-u-turn sampler: adaptively setting path lengths in hamiltonian monte carlo. Journal of Machine Learning Research, 15(1):1593–1623, 2014.   
+Hoffman, Matthew D, Blei, David M, Wang, Chong, and Paisley, John. Stochastic variational inference. JMLR, 2013.   
+Kingma, Diederik P and Welling, Max. Auto-encoding variational Bayes. In Proceedings of the International Conference on Learning Representations (ICLR), 2013.   
+Liu, Qiang and Wang, Dilin. Stein variational gradient descent: A general purpose bayesian inference algorithm. arXiv preprint arXiv:1608.04471, 2016.   
+Liu, Qiang, Lee, Jason D, and Jordan, Michael I. A kernelized Stein discrepancy for goodness-of-fit tests. In Proceedings of the International Conference on Machine Learning (ICML), 2016.   
+Maclaurin, Dougal, Duvenaud, David, and Adams, Ryan P. Early stopping is nonparametric variational inference. arXiv preprint arXiv:1504.01344, 2015.   
+Mandt, Stephan, Hoffman, Matthew D, and Blei, David M. A variational analysis of stochastic gradient algorithms. arXiv preprint arXiv:1602.02666, 2016.   
+Oates, Chris J, Girolami, Mark, and Chopin, Nicolas. Control functionals for Monte Carlo integration. Journal of the Royal Statistical Society, Series B, 2017.   
+Paige, Brooks and Wood, Frank. Inference networks for sequential monte carlo in graphical models. arXiv preprint arXiv:1602.06701, 2016.   
+Ranganath, R., Altosaar, J., Tran, D., and Blei, D.M. Operator variational inference. 2016.   
+Ranganath, Rajesh, Gerrish, Sean, and Blei, David M. Black box variational inference. In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS), 2014.   
+Ranganath, Rajesh, Tran, Dustin, and Blei, David M. Hierarchical variational models. arXiv preprint arXiv:1511.02386, 2015.   
+Rezende, Danilo Jimenez and Mohamed, Shakir. Variational inference with normalizing flows. In Proceedings of the International Conference on Machine Learning (ICML), 2015a.   
+Rezende, Danilo Jimenez and Mohamed, Shakir. Variational inference with normalizing flows. arXiv preprint arXiv:1505.05770, 2015b.   
+Roberts, Gareth O and Rosenthal, Jeffrey S. Examples of adaptive mcmc. Journal of Computational and Graphical Statistics, 18(2):349–367, 2009.   
+Salimans, Tim et al. Markov chain monte carlo and variational inference: Bridging the gap. In International Conference on Machine Learning, 2015.   
+Tran, Dustin, Ranganath, Rajesh, and Blei, David M. Variational gaussian process. arXiv preprint arXiv:1511.06499, 2015.   
+Wang, Dilin and Liu, Qiang. Learning to draw samples: With application to amortized mle for generative adversarial learning. Submitted to ICLR 2017, 2016.   
+Welling, Max and Teh, Yee W. Bayesian learning via stochastic gradient Langevin dynamics. In Proceedings of the International Conference on Machine Learning (ICML), 2011.

parse/train/Sy4tzwqxe/Sy4tzwqxe_content_list.json

@@ -0,0 +1,1426 @@
+[
+    {
+        "type": "text",
+        "text": "TWO METHODS FOR WILD VARIATIONAL INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            816,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Qiang Liu Yihao Feng   \nComputer Science, Dartmouth College   \nHanover, NH, 03755   \n{qiang.liu, yihao.feng.gr}@dartmouth.edu ",
+        "bbox": [
+            184,
+            145,
+            573,
+            202
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            237,
+            544,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Variational inference provides a powerful tool for approximate probabilistic inference on complex, structured models. Typical variational inference methods, however, require to use inference networks with computationally tractable probability density functions. This largely limits the design and implementation of variational inference methods. We consider wild variational inference methods that do not require tractable density functions on the inference networks, and hence can be applied in more challenging cases. As an example of application, we treat stochastic gradient Langevin dynamics (SGLD) as an inference network, and use our methods to automatically adjust the step sizes of SGLD, yielding significant improvement over the hand-designed step size schemes. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            430,
+            336,
+            445
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Probabilistic modeling provides a principled approach for reasoning under uncertainty, and has been increasingly dominant in modern machine learning where highly complex, structured probabilistic models are often the essential components for solving complex problems with increasingly larger datasets. A key challenge, however, is to develop computationally efficient Bayesian inference methods to approximate, or draw samples from the posterior distributions. Variational inference (VI) provides a powerful tool for scaling Bayesian inference to complex models and big data. The basic idea of VI is to approximate the true distribution with a simpler distribution by minimizing the KL divergence, transforming the inference problem into an optimization problem, which is often then solved efficiently using stochastic optimization techniques (e.g., Hoffman et al., 2013; Kingma & Welling, 2013). However, the practical design and application of VI are still largely restricted by the requirement of using simple approximation families, as we explain in the sequel. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            614
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Let $p ( z )$ be a distribution of interest, such as the posterior distribution in Bayesian inference. VI approximates $p ( z )$ with a simpler distribution $q ^ { * } ( z )$ found in a set $\\mathcal { Q } = \\{ q _ { \\eta } ( z ) \\}$ of distributions indexed by parameter $\\eta$ by minimizing the KL divergence objective: ",
+        "bbox": [
+            173,
+            621,
+            825,
+            662
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/579214cd81dc0f07f6a777e7772a6b8184d838c13132d28269d05841c7b081fc.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\eta } \\big \\{ \\mathrm { K L } ( q _ { \\eta } | | p ) \\equiv \\mathbb { E } _ { z \\sim q _ { \\eta } } [ \\log ( q _ { \\eta } ( z ) / p ( z ) ) ] \\big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            665,
+            653,
+            690
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "where we can get exact result $\\boldsymbol { p } = \\boldsymbol { q } ^ { * }$ if $\\mathcal { Q }$ is chosen to be broad enough to actually include $p$ . In practice, however, $\\mathcal { Q }$ should be chosen carefully to make the optimization in (1) computationally tractable; this casts two constraints on $\\mathcal { Q }$ : ",
+        "bbox": [
+            174,
+            693,
+            825,
+            734
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1. A minimum requirement is that we should be able to sample from $q _ { \\eta }$ efficiently, which allows us to make estimates and predictions based on $q _ { \\eta }$ in placement of the more intractable $p$ . The samples from $q _ { \\eta }$ can also be used to approximate the expectation $\\mathbb { E } _ { q } [ \\cdot ]$ in (1) during optimization. This means that there should exist some computable function $f ( \\eta ; \\xi )$ , called the inference network, which takes a random seed $\\xi$ , whose distribution is denoted by $q _ { 0 }$ , and outputs a random variable $z = f ( \\eta ; \\xi )$ whose distribution is $q _ { \\eta }$ . ",
+        "bbox": [
+            173,
+            741,
+            825,
+            827
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2. We should also be able to calculate the density $q _ { \\eta } ( z )$ or it is derivative in order to optimize the KL divergence in (1). This, however, casts a much more restrictive condition, since it requires us to use only simple inference network $f ( \\eta ; \\xi )$ and input distributions $q _ { 0 }$ to ensure a tractable form for the density $q _ { \\eta }$ of the output $z = f ( \\eta ; \\xi )$ . ",
+        "bbox": [
+            174,
+            832,
+            823,
+            890
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In fact, it is this requirement of calculating $q _ { \\eta } ( z )$ that has been the major constraint for the design of state-of-the-art variational inference methods. The traditional $\\mathrm { V I }$ methods are often limited to using simple mean field, or Gaussian-based distributions as $q _ { \\eta }$ and do not perform well for approximating complex target distributions. There is a line of recent work on variational inference with rich approximation families (e.g., Rezende & Mohamed, 2015b; Tran et al., 2015; Ranganath et al., 2015, to name only a few), all based on handcrafting special inference networks to ensure the computational tractability of $q _ { \\eta } ( z )$ while simultaneously obtaining high approximation accuracy. These approaches require substantial mathematical insights and research effects, and can be difficult to understand or use for practitioners without a strong research background in VI. Methods that allow us to use arbitrary inference networks without substantial constraints can significantly simplify the design and applications of VI methods, allowing practical users to focus more on choosing proposals that work best with their specific tasks. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/492f43da16371fc8172240c5ae93883a2e505491b54eb7915f5010a97f8cb46b.jpg",
+        "image_caption": [
+            "Figure 1: Wild variational inference allows us to train general stochastic neural inference networks to learn to draw (approximate) samples from the target distributions, without restriction on the computational tractability of the density function of the neural inference networks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            289,
+            101,
+            694,
+            185
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            261,
+            825,
+            400
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use the term wild variational inference to refer to variants of variational methods working with general inference networks $f ( \\eta , \\xi )$ without tractability constraints on its output density $q _ { \\eta } ( z )$ ; this should be distinguished with the black-box variational inference (Ranganath et al., 2014) which refers to methods that work for generic target distributions $p ( z )$ without significant model-by-model consideration (but still require to calculate the proposal density $q _ { \\eta } ( z ) _ { , }$ ). Essentially, wild variational inference makes it possible to “learn to draw samples”, constructing black-box neural samplers for given distributions. This enables more adaptive and automatic design of efficient Bayesian inference procedures, replacing the hand-designed inference algorithms with more efficient ones that can improve their efficiency adaptively over time based on past tasks they performed. ",
+        "bbox": [
+            174,
+            407,
+            825,
+            534
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we discuss two methods for wild variational inference, both based on recent works that combine kernel techniques with Stein’s method (e.g., Liu & Wang, 2016; Liu et al., 2016). The first method, also discussed in Wang & Liu (2016), is based on iteratively adjusting parameter $\\eta$ to make the random output $z = f ( \\eta ; \\xi )$ mimic a Stein variational gradient direction (SVGD) (Liu & Wang, 2016) that optimally decreases its KL divergence with the target distribution. The second method is based on minimizing a kernelized Stein discrepancy, which, unlike KL divergence, does not require to calculate density $q _ { \\eta } ( z )$ for the optimization thanks to its special form. ",
+        "bbox": [
+            174,
+            540,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another critical problem is to design good network architectures well suited for Bayesian inference. Ideally, the network design should leverage the information of the target distribution $p ( z )$ in a convenient way. One useful perspective is that we can view the existing MC/MCMC methods as (hand-designed) stochastic neural networks which can be used to construct native inference networks for given target distributions. On the other hand, using existing MC/MCMC methods as inference networks also allow us to adaptively adjust the hyper-parameters of these algorithms; this enables amortized inference which leverages the experience on past tasks to accelerate the Bayesian computation, providing a powerful approach for designing efficient algorithms in settings when a large number of similar tasks are needed. ",
+        "bbox": [
+            173,
+            643,
+            825,
+            768
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As an example, we leverage stochastic gradient Langevin dynamics (SGLD) (Welling & Teh, 2011) as the inference network, which can be treated as a special deep residential network (He et al., 2016), in which important gradient information $\\nabla _ { z } \\log { p ( z ) }$ is fed into each layer to allow efficient approximation for the target distribution $p ( z )$ . In our case, the network parameter $\\eta$ are the step sizes of SGLD, and our method provides a way to adaptively improve the step sizes, providing speed-up on future tasks with similar structures. We show that the adaptively estimated step sizes significantly outperform the hand-designed schemes such as Adagrad. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            873
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Related Works The idea of amortized inference (Gershman & Goodman, 2014) has been recently applied in various domains of probabilistic reasoning, including both amortized variational inference (e.g., Kingma & Welling, 2013; Rezende & Mohamed, 2015a) and date-driven designs of Monte Carlo based methods (e.g., Paige & Wood, 2016), to name only a few. Most of these methods, however, require to explicitly calculate $q _ { \\eta } ( z )$ (or its gradient). ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One well exception is a very recent work (Ranganath et al., 2016) that also avoids calculating $q _ { \\eta } ( z )$ and hence works for general inference networks; their method is based on a similar idea related to Stein discrepancy (Liu et al., 2016; Oates et al., 2017; Chwialkowski et al., 2016; Gorham & Mackey, 2015), for which we provide a more detailed discussion in Section 3.2. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The auxiliary variational inference methods (e.g., Agakov & Barber, 2004) provide an alternative way when the variational distribution $q _ { \\eta } ( z )$ can be represented as a hidden variable model. In particular, Salimans et al. (2015) used the auxiliary variational approach to leverage MCMC as a variational approximation. These approaches, however, still require to write down the likelihood function on the augmented spaces, and need to introduce an additional inference network related to the auxiliary variables. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            299
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There is a large literature on traditional adaptive MCMC methods (e.g., Andrieu & Thoms, 2008; Roberts & Rosenthal, 2009) which can be used to adaptively adjust the proposal distribution of MCMC by exploiting the special theoretical properties of MCMC (e.g., by minimizing the autocorrelation). Our method is simpler, more generic, and works efficiently in practice thanks to the use of gradient-based back-propagation. Finally, connections between stochastic gradient descent and variational inference have been discussed and exploited in Mandt et al. (2016); Maclaurin et al. (2015). ",
+        "bbox": [
+            173,
+            306,
+            825,
+            404
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Outline Section 2 introduces background on Stein discrepancy and Stein variational gradient descent. Section 3 discusses two methods for wild variational inference. Section 4 discuss using stochastic gradient Langevin dynamics (SGLD) as the inference network. Empirical results are shown in Section 5. ",
+        "bbox": [
+            173,
+            419,
+            825,
+            474
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 STEIN’S IDENTITY, STEIN DISCREPANCY, STEIN VARIATIONAL GRADIENT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            494,
+            821,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Stein’s identity Stein’s identity plays a fundamental role in our framework. Let $p ( z )$ be a positive differentiable density on $\\mathbb { R } ^ { d }$ , and $\\dot { \\phi ( z ) } = [ \\phi _ { 1 } ( z ) , \\cdot \\cdot \\cdot , \\phi _ { d } ( z ) ] ^ { \\top }$ is a differentiable vector-valued function. Define $\\begin{array} { r } { \\nabla _ { z } \\cdot \\phi = \\sum _ { i } \\partial _ { z _ { i } } \\phi } \\end{array}$ . Stein’s identity is ",
+        "bbox": [
+            174,
+            526,
+            825,
+            569
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f95e352caa4ff76618f15b985f808e5ba7bd5188b403c4e804f4d4dab80425a1.jpg",
+        "text": "$$\n\\mathbb { E } _ { z \\sim p } [ \\langle \\nabla _ { z } \\log p ( z ) , \\phi ( z ) \\rangle + \\nabla _ { z } \\cdot \\phi ( z ) ] = \\int _ { \\mathcal { X } } \\nabla _ { z } \\cdot ( p ( z ) \\phi ( z ) ) d x = 0 ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            261,
+            575,
+            735,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "which holds once $p ( z ) \\phi ( z )$ vanishes on the boundary of $\\mathcal { X }$ by integration by parts or Stokes’ theorem; It is useful to rewrite Stein’s identity in a more compact way: ",
+        "bbox": [
+            173,
+            613,
+            821,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/93aa870542ac84ea7f5de104a82238eef79cad76abf31408be332eff5af081ca.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } _ { z \\sim p } [ \\mathcal { T } _ { p } \\phi ( z ) ] = 0 , \\quad \\mathrm { ~ w i t h ~ } \\quad \\mathcal { T } _ { p } \\phi \\overset { d e f } { = } \\langle \\nabla _ { z } \\log p , \\phi \\rangle + \\nabla _ { z } \\cdot \\phi , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            648,
+            712,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { T } _ { p }$ is called a Stein operator, which acts on function $\\phi$ and returns a zero-mean function $\\mathcal { T } _ { p } \\phi ( z )$ under $z \\sim p$ . A key computational advantage of Stein’s identity and Stein operator is that they depend on $p$ only through the derivative of the log-density $\\nabla _ { z } \\log { p ( z ) }$ , which does not depend on the cumbersome normalization constant of $p$ , that is, when $p ( z ) = \\bar { p } ( z ) / Z$ , we have $\\nabla _ { z } \\log { p ( z ) } = \\nabla _ { z } \\log { \\bar { p } ( z ) }$ , independent of the normalization constant $Z$ . This property makes Stein’s identity a powerful practical tool for handling unnormalized distributions widely appeared in machine learning and statistics. ",
+        "bbox": [
+            173,
+            676,
+            825,
+            775
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Stein Discrepancy Although Stein’s identity ensures that $\\mathcal { T } _ { p } \\phi$ has zero expectation under $p$ , its expectation is generally non-zero under a different distribution $q$ . Instead, for $p \\neq q$ , there must exist a $\\phi$ which distinguishes $p$ and $q$ in the sense that $\\mathbb { E } _ { z \\sim q } [ \\mathcal { T } _ { p } \\phi ( z ) ] \\neq 0$ . Stein discrepancy leverages this fact to measure the difference between $p$ and $q$ by considering the “maximum violation of Stein’s identity” for $\\phi$ in certain function set $\\mathcal { F }$ : ",
+        "bbox": [
+            173,
+            789,
+            825,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/976fb877407295b45d151f5a9f4a3c7b9f28a620f592067ee95749cb0b0188c8.jpg",
+        "text": "$$\n\\mathbb { D } ( q | | p ) = \\operatorname* { m a x } _ { \\phi \\in \\mathcal { F } } \\big \\{ \\mathbb { E } _ { z \\sim q } [ \\mathcal { T } _ { p } \\phi ( z ) ] \\big \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            864,
+            614,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { F }$ is the set of functions $\\phi$ that we optimize over, and decides both the discriminative power and computational tractability of Stein discrepancy. Kernelized Stein discrepancy (KSD) is a special ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Stein discrepancy that takes $\\mathcal { F }$ to be the unit ball of vector-valued reproducing kernel Hilbert spaces (RKHS), that is, ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a51d63acb9fd6b8c26c1f12c01be76710b4e579253cfff8c74619ec59b81850f.jpg",
+        "text": "$$\n\\mathcal { F } = \\{ \\phi \\in \\mathcal { H } ^ { d } : | | \\phi | | _ { \\mathcal { H } ^ { d } } \\leq 1 \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            136,
+            599,
+            155
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { H }$ is a real-valued RKHS with kernel $k ( z , z ^ { \\prime } )$ . This choice of $\\mathcal { F }$ makes it possible to get a closed form solution for the optimization in (4) (Liu et al., 2016; Chwialkowski et al., 2016; Oates et al., 2017): ",
+        "bbox": [
+            176,
+            160,
+            823,
+            203
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d6a653e08ed091d6af2f044d1a2752cddbd27ee4adc027b785638267ca9d61a5.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathbb { D } ( q | | p ) = \\underset { \\phi \\in \\mathcal { H } ^ { d } } { \\operatorname* { m a x } } \\big \\lbrace \\mathbb { E } _ { z \\sim q } [ T _ { p } \\phi ( z ) ] , } & { \\quad s . t . \\quad | | \\phi | | _ { \\mathcal { H } ^ { d } } \\leq 1 \\big \\rbrace , } \\\\ { = \\sqrt { \\mathbb { E } _ { z , z ^ { \\prime } \\sim q } [ \\kappa _ { p } ( z , z ^ { \\prime } ) ] } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            205,
+            696,
+            265
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\kappa _ { p } \\big ( z , z ^ { \\prime } \\big )$ is a positive definite kernel obtained by applying Stein operator on $k ( z , z ^ { \\prime } )$ twice: ",
+        "bbox": [
+            173,
+            268,
+            812,
+            284
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/829bd1a6ceccc539fee194b7a83b31bf2cdb301b7f9800ea90e3e9a88e0b5860.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\kappa _ { p } ( z , z ^ { \\prime } ) = { \\mathcal { T } } _ { p } ^ { z ^ { \\prime } } ( { \\mathcal { T } } _ { p } ^ { z } \\otimes k ( z , z ^ { \\prime } ) ) , } \\\\ & { \\qquad = s _ { p } ( z ) s _ { p } ( z ^ { \\prime } ) k ( z , z ^ { \\prime } ) + s _ { p } ( z ) { \\nabla _ { z ^ { \\prime } } k ( z , z ^ { \\prime } ) } + s _ { p } ( z ^ { \\prime } ) { \\nabla _ { z } k ( z , z ^ { \\prime } ) } + { \\nabla _ { z } } \\cdot ( { \\nabla _ { z ^ { \\prime } } k ( z , z ^ { \\prime } ) } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            289,
+            808,
+            332
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\pmb { \\mathscr { s } } _ { p } ( z ) = \\nabla _ { z } \\log p ( z )$ and $\\mathcal { T } _ { p } ^ { z }$ and $\\mathcal { T } _ { p } ^ { z }$ denote the Stein operator when treating $k ( z , z ^ { \\prime } )$ as a function of $z$ and $z ^ { \\prime }$ , respectively; here we defined $\\begin{array} { r } { T _ { p } ^ { z } \\otimes k ( z , z ^ { \\prime } ) = \\nabla _ { x } \\log p ( x ) k ( z , z ^ { \\prime } ) + \\nabla _ { x } k ( z , z ^ { \\prime } ) } \\end{array}$ which returns a $d \\times 1$ vector-valued function. It can be shown that $\\mathbb { D } ( q | | p ) = 0$ if and only if $q = p$ when $k ( z , z ^ { \\prime } )$ is strictly positive definite in a proper sense (Liu et al., 2016; Chwialkowski et al., 2016). $\\mathbb { D } ( q \\mid \\mid p )$ can treated as a variant of maximum mean discrepancy equipped with kernel $\\kappa _ { p } \\big ( z , z ^ { \\prime } \\big )$ which depends on $p$ (which makes $\\mathbb { D } ( q | | p )$ asymmetric on $q$ and $p$ ). ",
+        "bbox": [
+            173,
+            348,
+            825,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The form of KSD in (6) allows us to estimate the discrepancy between a set of sample $\\left\\{ z _ { i } \\right\\}$ (e.g., drawn from $q$ ) and a distribution $p$ specified by $\\nabla _ { z } \\log { p ( z ) }$ , ",
+        "bbox": [
+            173,
+            444,
+            823,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/30d9a74b33f4d5815bf8d37efbbec89bb26bb509c0c627d941433d412498d626.jpg",
+        "text": "$$\n\\widehat { \\mathbb { D } } _ { u } ^ { 2 } ( \\{ z _ { i } \\} \\mid | p ) = \\frac { 1 } { n ( n - 1 ) } \\sum _ { i \\neq j } [ \\kappa _ { p } ( z _ { i } , z _ { j } ) ] , \\qquad \\widehat { \\mathbb { D } } _ { v } ^ { 2 } ( \\{ z _ { i } \\} \\mid | p ) = \\frac { 1 } { n ^ { 2 } } \\sum _ { i , j } [ \\kappa _ { p } ( z _ { i } , z _ { j } ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            215,
+            478,
+            779,
+            517
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\hat { \\mathbb { D } } _ { u } ^ { 2 } ( q | | \\operatorname { \\varepsilon } p )$ provides an unbiased estimator (hence called a $U$ -statistic) for $\\mathbb { D } ^ { 2 } ( q \\mid | \\ p )$ , and $\\hat { \\mathbb { D } } _ { v } ^ { 2 } ( q \\mid | \\ p )$ , called $V$ -statistic, provides a biased estimator but is guaranteed to be always nonnegative: $\\hat { \\mathbb { D } } _ { v } ^ { 2 } \\big ( \\{ z _ { i } \\} \\mid \\mid p \\big ) \\ge 0$ . ",
+        "bbox": [
+            173,
+            523,
+            825,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Stein Variational Gradient Descent (SVGD) Stein operator and Stein discrepancy have a close connection with KL divergence, which is exploited in Liu $\\&$ Wang (2016) to provide a general purpose deterministic approximate sampling method. Assume that $\\{ z _ { i } \\} _ { i = 1 } ^ { n }$ is a sample (or a set of particles) drawn from $q$ , and we want to update $\\{ z _ { i } \\} _ { i = 1 } ^ { n }$ to make it “move closer” to the target distribution $p$ to improve the approximation quality. We consider updates of form ",
+        "bbox": [
+            173,
+            587,
+            825,
+            659
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4abc5cdf14f24600855acad18449ee27c3009ddb71398a79da21779f156a5f9f.jpg",
+        "text": "$$\nz _ { i } \\gets z _ { i } + \\epsilon \\phi ^ { * } ( z _ { i } ) , \\quad \\forall i = 1 , \\dots , n ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            662,
+            620,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\phi ^ { * }$ is a perturbation direction, or velocity field, chosen to maximumly decrease the KL divergence between the distribution of updated particles and the target distribution, in the sense that ",
+        "bbox": [
+            174,
+            688,
+            828,
+            717
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c72f02705fb85bfe5f31de1d9a990c3865c6e891cb2d99cac8e432f8e53366da.jpg",
+        "text": "$$\n\\phi ^ { * } = \\underset { \\phi \\in \\mathcal { F } } { \\arg \\operatorname* { m a x } } \\bigg \\{ - \\frac { d } { d \\epsilon } \\mathrm { K L } ( q _ { [ \\epsilon \\phi ] } \\left| \\right| p ) \\big | _ { \\epsilon = 0 } \\bigg \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            722,
+            642,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { [ \\epsilon \\phi ] }$ denotes the density of the updated particle $z ^ { \\prime } = z + \\epsilon \\phi ( z )$ when the density of the original particle $z$ is $q$ , and $\\mathcal { F }$ is the set of perturbation directions that we optimize over. A key observation (Liu & Wang, 2016) is that the optimization in (11) is in fact equivalent to the optimization for KSD in (4); we have ",
+        "bbox": [
+            173,
+            763,
+            825,
+            819
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/91940743f46d75453800bfd73be8b1b8449acad656c02e92682473b159dde87e.jpg",
+        "text": "$$\n- \\frac { d } { d \\epsilon } \\mathrm { K L } ( q _ { [ \\epsilon \\phi ] } \\left| \\right| p ) \\big | _ { \\epsilon = 0 } = \\mathbb { E } _ { z \\sim q } [ \\mathcal { T } _ { p } \\phi ( z ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            824,
+            635,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "that is, the Stein operator transforms the perturbation $\\phi$ on the random variable (the particles) to the change of the KL divergence. Taking $\\mathcal { F }$ to be unit ball of $\\mathcal { H } ^ { d }$ as in (5), the optimal solution $\\phi ^ { * }$ of (11) equals that of (6), which is shown to be (e.g., Liu et al., 2016) ",
+        "bbox": [
+            173,
+            859,
+            825,
+            902
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d62fa7a894c31bffebc199b4bf3afe924c1826f8cadb8f34e223031d4da21040.jpg",
+        "text": "$$\n\\phi ^ { * } ( z ^ { \\prime } ) \\propto \\mathbb { E } _ { z \\sim q } [ \\mathcal { T } _ { p } ^ { z } k ( z , z ^ { \\prime } ) ] = \\mathbb { E } _ { z \\sim q } [ \\nabla _ { z } \\log p ( z ) k ( z , z ^ { \\prime } ) + \\nabla _ { z } k ( z , z ^ { \\prime } ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            907,
+            735,
+            926
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Amortized SVGD and KSD Minimization for Wild Variational Inference ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            738,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "for iteration t do ",
+        "bbox": [
+            189,
+            121,
+            303,
+            133
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. Draw random $\\{ \\xi _ { i } \\} _ { i = 1 } ^ { n }$ , calculate $z _ { i } = f ( \\eta ; \\xi _ { i } )$ , and the Stein variational gradient $\\Delta z _ { i }$ in (13). 2. Update parameter $\\eta$ using (14) or (15) for amortized SVGD, or (17) for KSD minimization. end for ",
+        "bbox": [
+            189,
+            136,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By approximating the expectation under $q$ with the empirical mean of the current particles $\\{ z _ { i } \\} _ { i = 1 } ^ { n }$ , SVGD admits a simple form of update that iteratively moves the particles towards the target distribution, ",
+        "bbox": [
+            174,
+            232,
+            823,
+            275
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd7c0a0cacaa1805565a866c9622cf4ecb8f0dc7fc1292413d56569301211fda.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\qquad z _ { i } \\gets z _ { i } + \\epsilon \\Delta z _ { i } , \\quad \\forall i = 1 , \\ldots , n , } \\\\ & { \\qquad \\Delta z _ { i } = \\hat { \\mathbb { E } } _ { z \\in \\{ z _ { i } \\} _ { i = 1 } ^ { n } } [ \\nabla _ { z } \\log p ( z ) k ( z , z _ { i } ) + \\nabla _ { z } k ( z , z _ { i } ) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            281,
+            678,
+            324
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\hat { \\mathbb { E } } _ { z \\sim \\{ z _ { i } \\} _ { i = 1 } ^ { n } } [ f ( z ) ] = \\sum _ { i } f ( z _ { i } ) / n } \\end{array}$ . The two terms in $\\Delta z _ { i }$ play two different roles: the term with the gradient $\\nabla _ { z } \\log { p ( z ) }$ drives the particles towards the high probability regions of $p ( z )$ , while the term with $\\nabla _ { z } k ( z , z _ { i } )$ serves as a repulsive force to encourage diversity; to see this, consider a stationary kernel $k ( z , z ^ { \\prime } ) = k ( z - z ^ { \\prime } )$ , then the second term reduces to $\\hat { \\mathbb { E } } _ { z } \\nabla _ { z } k ( z , z _ { i } ) =$ $- \\hat { \\mathbb { E } } _ { z } \\nabla _ { z _ { i } } k ( z , z _ { i } )$ , which can be treated as the negative gradient for minimizing the average similarity $\\hat { \\mathbb { E } } _ { z } k ( z , z _ { i } )$ in terms of $z _ { i }$ . ",
+        "bbox": [
+            173,
+            330,
+            825,
+            425
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It is easy to see from (13) that $\\Delta z _ { i }$ reduces to the typical gradient $\\nabla _ { z } \\log { p ( z _ { i } ) }$ when there is only a single particle $( n = 1$ ) and $\\nabla _ { z } k ( z , z _ { i } )$ when $z = z _ { i }$ , in which case SVGD reduces to the standard gradient ascent for maximizing $\\log p ( z )$ (i.e., maximum a posteriori (MAP)). ",
+        "bbox": [
+            174,
+            431,
+            825,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 TWO METHODS FOR WILD VARIATIONAL INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            494,
+            651,
+            511
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the direct parametric optimization of the KL divergence (1) requires calculating $q _ { \\eta } ( z )$ , there are two essential ways to avoid calculating $q _ { \\eta } ( z )$ : either using alternative (approximate) optimization approaches, or using different divergence objective functions. We discuss two possible approaches in this work: one based on “amortizing SVGD” (Wang & Liu, 2016) which trains the inference network $f ( \\eta , \\xi )$ so that its output mimic the SVGD dynamics in order to decrease the KL divergence; another based on minimizing the KSD objective (9) which does not require to evaluate $q ( z )$ thanks to its special form. ",
+        "bbox": [
+            173,
+            525,
+            825,
+            625
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 AMORTIZED SVGD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            352,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SVGD provides an optimal updating direction to iteratively move a set of particles $\\left\\{ z _ { i } \\right\\}$ towards the target distribution $p ( z )$ . We can leverage it to train an inference network $f ( \\eta ; \\xi )$ by iteratively adjusting $\\eta$ so that the output of $f ( \\eta ; \\xi )$ changes along the Stein variational gradient direction in order to maximumly decrease its KL divergence with the target distribution. By doing this, we “amortize” SVGD into a neural network, which allows us to leverage the past experience to adaptively improve the computational efficiency and generalize to new tasks with similar structures. Amortized SVGD is also presented in Wang $\\&$ Liu (2016); here we present some additional discussion. ",
+        "bbox": [
+            173,
+            666,
+            825,
+            765
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To be specific, assume $\\{ \\xi _ { i } \\}$ are drawn from $q _ { 0 }$ and $z _ { i } = f ( \\eta ; \\xi _ { i } )$ the corresponding random output based on the current estimation of $\\eta$ . We want to adjust $\\eta$ so that $z _ { i }$ changes along the Stein variational gradient direction $\\Delta z _ { i }$ in (13) so as to maximumly decrease the KL divergence with target distribution. This can be done by updating $\\eta$ via ",
+        "bbox": [
+            173,
+            771,
+            825,
+            828
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9e4095a2250329d1009ddb1acb1e1c277b237b19b3ad4cc5ce1381ad7c2c5126.jpg",
+        "text": "$$\n\\eta \\gets \\underset { \\eta } { \\arg \\operatorname* { m i n } } \\sum _ { i = 1 } ^ { n } | | f ( \\eta ; \\xi _ { i } ) - z _ { i } - \\epsilon \\Delta z _ { i } | | _ { 2 } ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            834,
+            645,
+            876
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Essentially, this projects the non-parametric perturbation direction $\\Delta z _ { i }$ to the change of the finite dimensional network parameter $\\eta$ . If we take the step size $\\epsilon$ to be small, then the updated $\\eta$ by (14) should be very close to the old value, and a single step of gradient descent of (14) can provide a ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "good approximation for (14). This gives a simpler update rule: ",
+        "bbox": [
+            173,
+            103,
+            583,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/400a004e19b866678ad66b3bf75f9d6c01edfc5a7cedc3bf2e8e3f7acc95ebbd.jpg",
+        "text": "$$\n\\eta  \\eta + \\epsilon \\sum _ { i } \\partial _ { \\eta } f ( \\eta ; \\xi _ { i } ) \\Delta z _ { i } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            126,
+            599,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which can be intuitively interpreted as a form of chain rule that back-propagates the SVGD gradient to the network parameter $\\eta$ . In fact, when we have only one particle, (15) reduces to the standard gradient ascent for $\\operatorname* { m a x } _ { \\eta } \\log p ( f ( \\eta ; ~ \\xi ) )$ , in which $f _ { \\eta }$ is trained to “learn to optimize” (e.g., Andrychowicz et al., 2016), instead of “learn to sample” $\\dot { p ( z ) }$ . Importantly, as we have more than one particles, the repulsive term $\\nabla _ { z } k ( z , z _ { i } )$ in $\\Delta z _ { i }$ becomes active, and enforces an amount of diversity on the network output that is consistent with the variation in $p ( z )$ . The full algorithm is summarized in Algorithm 1. ",
+        "bbox": [
+            173,
+            166,
+            825,
+            266
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Amortized SVGD can be treated as minimizing the KL divergence using a rather special algorithm: it leverages the non-parametric SVGD which can be treated as approximately solving the infinite dimensional optimization ${ \\mathrm { m i n } } _ { q } \\operatorname { K L } ( q | | p )$ without explicitly assuming a parametric form on $q$ , and iteratively projecting the non-parametric update back to the finite dimensional parameter space of $\\eta$ . It is an interesting direction to extend this idea to “amortize” other MC/MCMC-based inference algorithms. For example, given a MCMC with transition probability $T ( z ^ { \\prime } | z )$ whose stationary distribution is $p ( z )$ , we may adjust $\\eta$ to make the network output move towards the updated values $z ^ { \\prime }$ drawn from the transition probability $T ( z ^ { \\prime } | z )$ . The advantage of using SVGD is that it provides a deterministic gradient direction which we can back-propagate conveniently and is particle efficient in that it reduces to “learning to optimize” with a single particle. We have been using the simple $L ^ { 2 }$ loss in (14) mainly for convenience; it is possible to use other two-sample discrepancy measures such as maximum mean discrepancy. ",
+        "bbox": [
+            173,
+            271,
+            825,
+            439
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 KSD VARIATIONAL INFERENCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            457,
+            434,
+            472
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Amortized SVGD attends to minimize the KL divergence objective, but can not be interpreted as a typical finite dimensional optimization on parameter $\\eta$ . Here we provide an alternative method based on directly minimizing the kernelized Stein discrepancy (KSD) objective, for which, thanks to its special form, the typical gradient-based optimization can be performed without needing to estimate $q ( z )$ explicitly. ",
+        "bbox": [
+            174,
+            483,
+            825,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To be specific, take $q _ { \\eta }$ to be the density of the random output $z = f ( \\eta ; \\xi )$ when $\\xi \\sim q _ { 0 }$ , and we want to find $\\eta$ to minimize $\\mathbb { D } ( q _ { \\eta } \\parallel p )$ . Assuming $\\{ \\xi _ { i } \\}$ is i.i.d. drawn from $q _ { 0 }$ , we can approximate $\\mathbb { D } ^ { 2 } ( q _ { \\eta } | | p )$ unbiasedly with a U-statistics: ",
+        "bbox": [
+            174,
+            560,
+            825,
+            606
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4cfab198ac0e12bd90ad06506fe92ab82423436555ec19c2ac63a071a279d7a6.jpg",
+        "text": "$$\n\\mathbb { D } ^ { 2 } ( q _ { \\eta } | | p ) \\approx \\frac { 1 } { n ( n - 1 ) } \\sum _ { i \\neq j } \\kappa _ { p } ( f ( \\eta ; \\xi _ { i } ) , f ( \\eta ; \\xi _ { j } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            613,
+            673,
+            654
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "for which a standard gradient descent can be derived for optimizing $\\eta$ : ",
+        "bbox": [
+            173,
+            660,
+            633,
+            676
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a614daf519267837fc074b409839106d9a28865e7214b739704500dcd7881c14.jpg",
+        "text": "$$\n\\eta  \\eta - \\epsilon \\frac { 2 } { n ( n - 1 ) } \\sum _ { i \\neq j } \\partial _ { \\eta } f ( \\eta ; \\xi _ { i } ) \\nabla _ { z _ { i } } \\kappa _ { p } ( z _ { i } , z _ { j } ) , \\quad \\mathrm { ~ w h e r e ~ } \\quad z _ { i } = f ( \\eta ; \\xi _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            243,
+            683,
+            754,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "This enables a wild variational inference method based on directly minimizing $\\eta$ with standard (stochastic) gradient descent. See Algorithm 1. Note that (17) is similar to (15) in form, but replaces ∆zi with a ∆˜ zi ∝ − Pj : i6=j $\\begin{array} { r } { \\tilde { \\Delta } z _ { i } \\propto - \\sum _ { j : i \\neq j } \\nabla _ { z _ { i } } \\bar { \\kappa } _ { p } ( z _ { i } , z _ { j } ) } \\end{array}$ . It is also possible to use the $V$ -statistic in (9), but we find that the $U$ -statistic performs much better in practice, possibly because of its unbiasedness property. ",
+        "bbox": [
+            173,
+            729,
+            825,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Minimizing KSD can be viewed as minimizing a constrastive divergence objective function. To see this, recall that $q _ { [ \\epsilon \\phi ] }$ denotes the density of $z ^ { \\prime } = z + \\epsilon \\phi ( z )$ when $z \\sim q$ . Combining (11) and (6), we can show that ",
+        "bbox": [
+            174,
+            809,
+            825,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e696a5ec03701a7f33bc84e25685c9d249fd78b208eb7f895ca7950fea927802.jpg",
+        "text": "$$\n\\mathbb { D } ^ { 2 } ( q | | p ) \\approx \\frac { 1 } { \\epsilon } ( \\mathrm { K L } ( q | | p ) - \\mathrm { K L } ( q _ { [ \\epsilon \\phi ] } | | p ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            858,
+            648,
+            887
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "That is, KSD measures the amount of decrease of $\\mathrm { K L }$ divergence when we update the particles along the optimal SVGD perturbation direction $\\phi$ given by (11). If $q = p$ , then the decrease of KL ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "divergence equals zero and $\\mathbb { D } ^ { 2 } ( q | | p )$ equals zero. In fact, as shown in Liu & Wang (2016) KSD can be explicitly represented as the magnitude of a functional gradient of KL divergence: ",
+        "bbox": [
+            171,
+            102,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4dfcaed5ab64a2f2ffe64807019a6c5c94c588b14f6c1898ad043c36f7b7566a.jpg",
+        "text": "$$\n\\mathbb { D } ( q \\parallel p ) = \\biggl \\| \\frac { d } { d \\phi } \\mathrm { K L } ( q _ { [ \\phi ] } \\parallel p ) \\bigr | _ { \\phi = 0 } \\biggl | \\biggl | _ { \\mathcal { H } ^ { d } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            138,
+            632,
+            171
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $q _ { [ \\phi ] }$ is the density of $z = z + \\phi ( z )$ when $z \\sim q$ , and $\\textstyle { \\frac { d } { d \\phi } } F ( \\phi )$ denotes the functional gradient of functional $F ( \\phi )$ w.r.t. $\\phi$ defined in RKHS $\\mathcal { H } ^ { d }$ , and $\\begin{array} { r } { \\frac { d } { d \\phi } F ( { \\dot { \\phi } } ) } \\end{array}$ is also an element in $\\mathcal { H } ^ { d }$ . Therefore, KSD variational inference can be treated as explicitly minimizing the magnitude of the gradient of KL divergence, in contract with amortized SVGD which attends to minimize the KL divergence objective itself. ",
+        "bbox": [
+            173,
+            179,
+            825,
+            257
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This idea is also similar to the contrastive divergence used for learning restricted Boltzmann machine (RBM) (Hinton, 2002) (which, however, optimizes $p$ with fixed $q$ ). It is possible to extend this approach by replacing $z ^ { \\prime } = z + \\epsilon \\phi ( z )$ with other transforms, such as these given by a transition probability of a Markov chain whose stationary distribution is $p$ . In fact, according the so called generator method for constructing Stein operator (Barbour, 1988), any generator of a Markov process defines a Stein operator that can be used to define a corresponding Stein discrepancy. ",
+        "bbox": [
+            173,
+            263,
+            825,
+            348
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This idea is related to a very recent work by Ranganath et al. (2016), which is based on directly minimizing the variational form of Stein discrepancy in (4); Ranganath et al. (2016) assumes $\\mathcal { F }$ consists of a neural network $\\phi _ { \\tau } ( z )$ parametrized by $\\tau$ , and find $\\eta$ by solving the following min-max problem: ",
+        "bbox": [
+            174,
+            353,
+            825,
+            410
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3ee506e1a179eba9bde4397b20dd1e575ec0d1faa7fbe9921400e24933f80eeb.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\eta } \\operatorname* { m a x } _ { \\tau } \\mathbb { E } _ { z \\sim q } [ \\mathcal { T } _ { p } \\phi _ { \\tau } ( z ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            411,
+            409,
+            584,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, our method leverages the closed form solution by taking $\\mathcal { F }$ to be an RKHS and hence obtains an explicit optimization problem, instead of a min-max problem that can be computationally more expensive, or have difficulty in achieving convergence. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Because $\\kappa _ { p } ( \\boldsymbol { x } , \\boldsymbol { x } ^ { \\prime } )$ (defined in (8)) depends on the derivative $\\nabla _ { x } \\log p ( x )$ of the target distribution, the gradient in (17) depends on the Hessian matrix $\\nabla _ { x } ^ { 2 } \\log p ( x )$ and is hence less convenient to implement compared with amortized SVGD (the method by Ranganath et al. (2016) also has the same problem). However, this problem can be alleviated using automatic differentiation tools, which be used to directly take the derivative of the objective in (16) without manually deriving its derivatives. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            556
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 LANGEVIN INFERENCE NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            575,
+            490,
+            592
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "With wild variational inference, we can choose more complex inference network structures to obtain better approximation accuracy. Ideally, the best network structure should leverage the special properties of the target distribution $p ( z )$ in a convenient way. One way to achieve this by viewing existing MC/MCMC methods as inference networks with hand-designed (and hence potentially suboptimal) parameters, but good architectures that take the information of the target distribution $p ( z )$ into account. By applying wild variational inference on networks constructed based on existing MCMC methods, we effectively provide an hyper-parameter optimization for these existing methods. This allows us to fully optimize the potential of existing Bayesian inference methods, significantly improving the result with less computation cost, and decreasing the need for hyper-parameter tuning by human experts. This is particularly useful when we need to solve a large number of similar tasks, where the computation cost spent on optimizing the hyper-parameters can significantly improve the performance on the future tasks. ",
+        "bbox": [
+            173,
+            607,
+            825,
+            775
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Gradient Langevin Dynamics We first take the original stochastic gradient Langevin dynamics (SGLD) algorithm (Welling & Teh, 2011) as an example. SGLD starts with a random initialization $z _ { \\mathrm { 0 } }$ , and perform iterative update of form ",
+        "bbox": [
+            174,
+            790,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4019152a5363819c6e7ede3ee2b8ecafdf5ccebabf94e085f51b421c7395dc2f.jpg",
+        "text": "$$\nz ^ { t + 1 } \\gets z ^ { t } + \\eta ^ { t } \\odot \\nabla _ { z } \\log \\hat { p } ( z ^ { t } ; \\mathbb { M } ^ { t } ) + \\sqrt { 2 \\eta ^ { t } } \\odot \\xi ^ { t } , \\quad \\forall t = 1 , \\cdot \\cdot \\cdot T ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            839,
+            723,
+            859
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\log \\hat { p } ( z ^ { t } ; \\ \\mathbb { M } ^ { t } )$ denotes an approximation of $\\log p ( z ^ { t } )$ based on, e.g., a random mini-batch $\\mathbb { M } ^ { t }$ of observed data at $t$ -th iteration, and $\\xi ^ { t }$ is a standard Gaussian random vector of the same size as $z$ , and $\\eta ^ { t }$ denotes a (vector) step-size at $t$ -th iteration; here “ $\\odot$ ” denotes element-wise product. When running SGLD for $T$ iterations, we can treat $z ^ { T }$ as the output of a $T$ -layer neural network parametrized by the collection of step sizes $\\eta = \\{ \\eta ^ { t } \\} _ { t = 1 } ^ { T }$ , whose random inputs include the random initialization $z _ { \\mathrm { 0 } }$ , the mini-batch $\\mathbb { M } ^ { t }$ and Gaussian noise $\\xi ^ { t }$ at each iteration $t$ . We can see that this defines a rather complex network structure with several different types of random inputs $( z ^ { 0 } , \\mathbb { M } ^ { t }$ and $\\boldsymbol { \\xi } ^ { t }$ ). This makes it intractable to explicitly calculate the density of $z ^ { T }$ and traditional variational inference methods can not be applied directly. But wild variational inference can still allow us to adaptively improve the optimal step-size $\\eta$ in this case. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/d01a7e1c35323e43b5217ad65d7e281f4bd1b1cefac515f6b3a5b589310d9d9a.jpg",
+        "image_caption": [
+            "Figure 2: Results on a 1D Gaussian mixture when training the step sizes of SGLD with $T = 2 0$ iterations. The target distribution $p ( x )$ is shown by the red dashed line. (a) The distribution of the initialization $z _ { 0 }$ of SGLD (the green line), visualized by kernel density estimator. (b)-(d) The distribution of the final output $z ^ { T }$ (green line) given by different types of step sizes, visualized by kernel density estimator. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            101,
+            818,
+            205
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            318,
+            825,
+            402
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "General Langevin Networks Based on the original formula of SGLD, we proposed a more general langevin network structure, and each layer of the network has a form ",
+        "bbox": [
+            169,
+            417,
+            823,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/caa89fa497f6509bef2922859a9004c659f38e17c7cf78b36dcfc485c018dc41.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { z ^ { t + 1 } \\gets A ^ { t } z ^ { t } + h ( B ^ { t } B ^ { t } ^ { \\top } \\nabla _ { z } \\log \\hat { p } ( z ^ { t } ; \\mathbb { M } ^ { t } ) + B ^ { t } \\xi ^ { t } + D ^ { t } ) , \\quad } & { \\forall t = 1 , \\cdots T , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            454,
+            759,
+            476
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $A ^ { t } , B ^ { t }$ and $D ^ { t }$ are network parameters at $t$ -th iteration(whose size is $d \\times d$ , and $d$ is the size of $z ^ { t }$ ), and $h ( \\cdot )$ denotes a smooth element-wise non-linearity function; here $\\xi ^ { t }$ is still a standard gaussian random vector with the same size as $z$ . With this more complex network, we can use fewer layers to construct more powerful back-box samplers. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 EMPIRICAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            561,
+            382,
+            578
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 SGLD INFERENCE NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            421,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We first test our algorithm with SGLD inference network with (18) formula on both a toy Gaussian mixture model and a Bayesian logistic regression example. We find that we can adaptively learn step sizes that significantly outperform the existing hand-designed step size schemes, and hence save computational cost in the testing phase. In particular, we compare with the following step size schemes, for all of which we report the best results (testing accuracy in Figure 3(a); testing likelihood in Figure 3(b)) among a range of hyper-parameters: ",
+        "bbox": [
+            173,
+            619,
+            825,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1. Constant Step Size. We select a best constant step size in $\\{ 1 , 2 , 2 ^ { 3 } , \\dots , 2 ^ { 2 9 } \\} \\times 1 0 ^ { - 6 }$ . ",
+        "bbox": [
+            173,
+            709,
+            746,
+            727
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "2. Power Decay Step Size. We consider $\\epsilon ^ { t } ~ = ~ 1 0 ^ { a } ~ \\times ~ ( b + t ) ^ { - \\gamma }$ where $\\gamma \\ = \\ 0 . 5 5$ , $a \\in$ $\\{ - 6 , - 5 , \\ldots , 1 , 2 \\}$ , $b \\in \\{ 0 , 1 , \\ldots , 9 \\}$ . ",
+        "bbox": [
+            173,
+            731,
+            820,
+            762
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3. Adagrad, Rmsprop, Adadelta, all with the master step size selected in $\\{ 1 , 2 , 2 ^ { 3 } , \\dots , 2 ^ { 2 9 } \\} \\times 1 0 ^ { - 6 }$ , with the other parameters chosen by default values. ",
+        "bbox": [
+            173,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Gaussian Mixture We start with a simple 1D Gaussian mixture example shown in Figure 2 where the target distribution $p ( z )$ is shown by the red dashed curve. We use amortized SVGD and KSD to optimize the step size parameter of the Langevin inference network in (18) with $T = 2 0$ layers (i.e., SGLD with $T = 2 0$ iterations), with an initial $z _ { \\mathrm { 0 } }$ drawn from a $q _ { 0 }$ far away from the target distribution (see the green curve in Figure 2(a)); this makes it critical to choose a proper step size to achieve close approximation within $T = 2 0$ iterations. We find that amortized SVGD and KSD allow us to achieve good performance with 20 steps of SGLD updates (Figure 2(b)-(c)), while the result of the best constant step size and power decay step-size are much worse (Figure 2(d)-(e)). ",
+        "bbox": [
+            173,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/858102adb7f3c954e9a9dd7b03a65ea02c4fcccf9767ec7a02edd22091c97062.jpg",
+        "image_caption": [
+            "Figure 3: The testing accuracy (a) and testing likelihood (b) when training Langevin inference network with $T \\in \\{ 1 0 , \\bar { 5 } 0 , 1 0 0 \\}$ layers, respectively. The results reported here are the performance of the final result $z ^ { T }$ outputted by the last layer of the network. We find that both amortized SVGD and KSD minimization (with $\\mathrm { U }$ -statistics) outperform all the hand-designed learning rates. Results averaged on 100 random trails. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            210,
+            99,
+            779,
+            250
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bayesian Logistic Regression We consider Bayesian logistic regression for binary classification using the same setting as Gershman et al. (2012), which assigns the regression weights $w$ with a Gaussian prior $p _ { 0 } ( w | \\bar { \\alpha } ) = \\mathcal { N } ( w , \\alpha ^ { - 1 } )$ and $p _ { 0 } ( \\alpha ) = G a m m a ( \\alpha , 1 , 0 . 0 1 )$ . The inference is applied on the posterior of $z = [ w , \\log \\alpha ]$ . We test this model on the binary Covertype dataset1 with 581,012 data points and 54 features. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate that our estimated learning rate can work well on new datasets never seen by the algorithm. We partition the dataset into mini-datasets of size 50, 000, and use $8 0 \\%$ of them for training and $2 0 \\%$ for testing. We adapt our amortized SVGD/KSD to train on the whole population of the training mini-datasets by randomly selecting a mini-dataset at each iteration of Algorithm 1, and evaluate the performance of the estimated step sizes on the remaining $2 0 \\%$ testing mini-datasets. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 reports the testing accuracy and likelihood on the $2 0 \\%$ testing mini-datasets when we train the Langevin network with $T = 1 0 , 5 0 , 1 0 0$ layers, respectively. We find that our methods outperform all the hand-designed learning rates, and allow us to get performance closer to the fully converged SGLD and SVGD with a small number $T$ of iterations. ",
+        "bbox": [
+            174,
+            512,
+            825,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Figure 4 shows the testing accuracy and testing likelihood of all the intermediate results when training Langevin network with $T = 1 0 0$ layers. It is interesting to observe that amortized SVGD and KSD learn rather different behavior: KSD tends to increase the performance quickly at the first few iterations but saturate quickly, while amortized SVGD tends to increase slowly in the beginning and boost the performance quickly in the last few iterations. Note that both algorithms are set up to optimize the performance of the last layers, while need to decide how to make progress on the intermediate layers to achieve the best final performance. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            672
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 GENERAL LANGEVIN INFERENCE NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            690,
+            524,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We further test our algorithm with general Langevin inference network. We firstly construct one single layer general Langevin network to approach the posterior of Bayesian logistic regression parameters and we can achieve $7 4 . 5 8 \\%$ average accuracy and $- 0 . 5 2 1 6$ average testing log-likelihood in 100 repeat experiments. This result proves the proposed general Langevin Inference Network is quite competitive and worth to explore. Moreover, we use it as a black-box sampler to approach more complicate Gaussian Mixture distributions. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            801
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gaussian Mixture We consider 10 components Gaussian Mixture Models with mean and covariance matrix of each component randomly drawed from a uniform distribution, and we test our methods on different dimensions models. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We construct 6 layers of general Langevin networks as a black-box sampler, and our proposed two methods to train the black-box sampler to approximate the target distribution. Figure 5 shows our results on 50 dimension Gaussian Mixture case and figure 6 shows results of different dimensions of Gaussian Mixture. From the figures we can know that our proposed sampling structure is quite competive comparing with NUT sampler(Hoffman & Gelman, 2014), and these two variational inference methods can both train a good black-box sampler. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            897
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/b51f406093bed295d5f6b9f4bff9d74ab2e413a98fae5aae64a7c4df31ea9c26.jpg",
+        "image_caption": [
+            "Figure 4: The testing accuracy (a) and testing likelihood (b) of the outputs of the intermediate layers when training the Langevin network with $\\bar { T } = 1 0 0$ layers. Note that both amortized SVGD and KSD minimization target to optimize the performance of the last layer, but need to optimize the progress of the intermediate steps in order to achieve the best final results. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            98,
+            794,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            358,
+            825,
+            415
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/11ffb85315b5278fdeac6e9921e4cc43945ee3da66dcc44852474a305675e7ab.jpg",
+        "image_caption": [
+            "Figure 5: Comparation between our methods and NUTS on 50 dimension Gaussian Mixture. (a)-(c) show the mean square errors when using different number particles to estimate expectation $\\mathbb { E } ( h ( x ) )$ for $h ( x ) = x$ , $\\bar { x ^ { 2 } }$ , and $c o s ( x + b )$ ; for $\\cos ( \\omega x + b )$ , we random draw $\\omega \\sim \\mathcal { N } ( 0 , 1 )$ and $b \\sim$ Uniform $( [ 0 , 2 \\pi ] )$ and report the average MSE over 10 random draws of and b. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            436,
+            828,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/08bb781eebe5730a7ad456b1b4ed41bb9785a9a7f86452204c07c4983560432e.jpg",
+        "image_caption": [
+            "Figure 6: Comparation between our methods and NUTS For different dimension Gaussian Mixture. (a)-(c) show the mean square errors when using different number particles to estimate expectation $\\mathbb { E } ( h ( x ) )$ for $h ( x ) = x ,$ , $\\overline { { x ^ { 2 } } }$ , and $c o s ( x + b )$ ; for $c o s ( \\omega x + b )$ , we random draw $\\omega \\sim \\mathcal { N } ( 0 , 1 )$ and $\\boldsymbol { b } \\sim \\operatorname { U n i f o r m } ( [ 0 , 2 \\pi ] )$ and report the average MSE over 10 random draws of and b. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            691,
+            828,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We consider two methods for wild variational inference that allows us to train general inference networks with intractable density functions, and apply it to adaptively estimate step sizes of stochastic gradient Langevin dynamics. More studies are needed to develop better methods, more applications and theoretical understandings for wild variational inference, and we hope that the two methods we discussed in the paper can motivate more ideas and studies in the field. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            204
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            285,
+            238
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Agakov, Felix V and Barber, David. An auxiliary variational method. In International Conference on Neural Information Processing, pp. 561–566. Springer, 2004.   \nAndrieu, Christophe and Thoms, Johannes. A tutorial on adaptive mcmc. Statistics and Computing, 18(4): 343–373, 2008.   \nAndrychowicz, Marcin, Denil, Misha, Gomez, Sergio, Hoffman, Matthew W, Pfau, David, Schaul, Tom, and de Freitas, Nando. Learning to learn by gradient descent by gradient descent. arXiv preprint arXiv:1606.04474, 2016.   \nBarbour, Andrew D. Stein’s method and poisson process convergence. Journal of Applied Probability, pp. 175–184, 1988.   \nChwialkowski, Kacper, Strathmann, Heiko, and Gretton, Arthur. A kernel test of goodness of fit. In Proceedings of the International Conference on Machine Learning (ICML), 2016.   \nGershman, Samuel, Hoffman, Matt, and Blei, David. Nonparametric variational inference. In Proceedings of the International Conference on Machine Learning (ICML), 2012.   \nGershman, Samuel J and Goodman, Noah D. Amortized inference in probabilistic reasoning. In Proceedings of the 36th Annual Conference of the Cognitive Science Society, 2014.   \nGorham, Jack and Mackey, Lester. Measuring sample quality with Stein’s method. In Advances in Neural Information Processing Systems (NIPS), pp. 226–234, 2015.   \nHe, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Deep residual learning for image recognition. In CVPR, 2016.   \nHinton, Geoffrey E. Training products of experts by minimizing contrastive divergence. Neural computation, 14(8):1771–1800, 2002.   \nHoffman, Matthew D and Gelman, Andrew. The no-u-turn sampler: adaptively setting path lengths in hamiltonian monte carlo. Journal of Machine Learning Research, 15(1):1593–1623, 2014.   \nHoffman, Matthew D, Blei, David M, Wang, Chong, and Paisley, John. Stochastic variational inference. JMLR, 2013.   \nKingma, Diederik P and Welling, Max. Auto-encoding variational Bayes. In Proceedings of the International Conference on Learning Representations (ICLR), 2013.   \nLiu, Qiang and Wang, Dilin. Stein variational gradient descent: A general purpose bayesian inference algorithm. arXiv preprint arXiv:1608.04471, 2016.   \nLiu, Qiang, Lee, Jason D, and Jordan, Michael I. A kernelized Stein discrepancy for goodness-of-fit tests. In Proceedings of the International Conference on Machine Learning (ICML), 2016.   \nMaclaurin, Dougal, Duvenaud, David, and Adams, Ryan P. Early stopping is nonparametric variational inference. arXiv preprint arXiv:1504.01344, 2015.   \nMandt, Stephan, Hoffman, Matthew D, and Blei, David M. A variational analysis of stochastic gradient algorithms. arXiv preprint arXiv:1602.02666, 2016.   \nOates, Chris J, Girolami, Mark, and Chopin, Nicolas. Control functionals for Monte Carlo integration. Journal of the Royal Statistical Society, Series B, 2017.   \nPaige, Brooks and Wood, Frank. Inference networks for sequential monte carlo in graphical models. arXiv preprint arXiv:1602.06701, 2016.   \nRanganath, R., Altosaar, J., Tran, D., and Blei, D.M. Operator variational inference. 2016.   \nRanganath, Rajesh, Gerrish, Sean, and Blei, David M. Black box variational inference. In Proceedings of the International Conference on Artificial Intelligence and Statistics (AISTATS), 2014.   \nRanganath, Rajesh, Tran, Dustin, and Blei, David M. Hierarchical variational models. arXiv preprint arXiv:1511.02386, 2015.   \nRezende, Danilo Jimenez and Mohamed, Shakir. Variational inference with normalizing flows. In Proceedings of the International Conference on Machine Learning (ICML), 2015a.   \nRezende, Danilo Jimenez and Mohamed, Shakir. Variational inference with normalizing flows. arXiv preprint arXiv:1505.05770, 2015b.   \nRoberts, Gareth O and Rosenthal, Jeffrey S. Examples of adaptive mcmc. Journal of Computational and Graphical Statistics, 18(2):349–367, 2009.   \nSalimans, Tim et al. Markov chain monte carlo and variational inference: Bridging the gap. In International Conference on Machine Learning, 2015.   \nTran, Dustin, Ranganath, Rajesh, and Blei, David M. Variational gaussian process. arXiv preprint arXiv:1511.06499, 2015.   \nWang, Dilin and Liu, Qiang. Learning to draw samples: With application to amortized mle for generative adversarial learning. Submitted to ICLR 2017, 2016.   \nWelling, Max and Teh, Yee W. Bayesian learning via stochastic gradient Langevin dynamics. In Proceedings of the International Conference on Machine Learning (ICML), 2011. ",
+        "bbox": [
+            171,
+            242,
+            828,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            101,
+            828,
+            438
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ryG6xZ-RZ/ryG6xZ-RZ.md

@@ -0,0 +1,169 @@
+# DLVM: A MODERN COMPILER INFRASTRUCTURE FOR DEEP LEARNING SYSTEMS
+
+Richard Wei   
+Departments of Computer Science & Linguistics   
+University of Illinois at Urbana-Champaign   
+Urbana, IL 61801   
+xwei12@illinois.edu   
+Lane Schwartz   
+Department of Linguistics   
+University of Illinois at Urbana-Champaign   
+Urbana, IL 61801   
+lanes@illinois.edu
+
+# Vikram Adve
+
+Department of Computer Science   
+University of Illinois at Urbana-Champaign   
+Urbana, IL 61801   
+vadve@illinois.edu
+
+# ABSTRACT
+
+Deep learning software demands reliability and performance. However, many of the existing deep learning frameworks are software libraries that act as an unsafe DSL in Python and a computation graph interpreter. We present DLVM, a design and implementation of a compiler infrastructure with a linear algebra intermediate representation, algorithmic differentiation by adjoint code generation, domainspecific optimizations and a code generator targeting GPU via LLVM. Designed as a modern compiler infrastructure inspired by LLVM, DLVM is more modular and more generic than existing deep learning compiler frameworks, and supports tensor DSLs with high expressivity. With our prototypical staged DSL embedded in Swift, we argue that the DLVM system enables a form of modular, safe and performant frameworks for deep learning.
+
+# 1 INTRODUCTION
+
+Within the deep learning community, most current approaches to neural networks make use of high-level frameworks with a tensor domain-specific language (DSL) such as Torch (Collobert et al., 2011), TensorFlow (Abadi et al., 2016), PyTorch (PyTorch Development Team, 2016), and MXNet (Chen et al., 2015). Traditionally, developers would build a computation graph (or dynamically generate graph nodes) using a DSL and let the framework interpret the computation graph on parallel architectures such as NVIDIA GPUs. While using hand-tuned GPU subroutines usually yields the best performance for complex operators, advanced compiler techniques can be applied to simplify computation, merge high-level operators based on shaping conditions, and fuse compatible elementwise operators to a single kernel to minimize the latency between kernel launches. Recent projects, the TensorFlow XLA compiler (Leary & Wang, 2017) and the NNVM compiler (NNVM, 2017) including TVM (Chen et al., 2017), have begun to apply compiler techniques to deep learning systems, targeting LLVM (Lattner & Adve, 2004) and various back-ends to achieve good performance. However, their design and implementation have not entirely followed established best practices in widely-used compiler frameworks in the industry.
+
+Moreover, some frameworks use operator-overloading algorithmic differentiation (AD) to compute gradients, leaving the gradient computation unoptimizable. The other approach to AD, source code transformation, can produce more efficient code. While frameworks such as TensorFlow already perform AD as a graph transformation and apply various optimizations, their AD transformation is not designed as a transformation pass in the pipeline of their compiler framework, but as part of the DSL library. Making AD part of the compiler framework would greatly simplify the development of DSLs, achieving separation of concerns.
+
+![](images/849b709b69e101ea7ef26d6864d1b1e0eafec6758703952e4749d0cbe5bb8354.jpg)  
+Figure 1: Software stack of the DLVM infrastructure. Blue components are the compiler framework.
+
+We introduce DLVM, a new compiler infrastructure for deep learning systems that addresses shortcomings of existing deep learning frameworks. Our solution includes (1) a domain-specific intermediate representation specifically designed for tensor computation, (2) principled use of modern compiler optimization techniques to substantially simplify neural network computation, including algebra simplification, AD checkpointing, compute kernel fusion, and various traditional compiler optimizations, (3) code generation through a mature compiler infrastructure that allows for transparent targeting of various hardware, and (4) an embedded DSL that supports static analysis, type safety, and natural expression of tensor computation, and has a just-in-time (JIT) compiler targeting DLVM for AD, optimizations, and code generation.
+
+# 2 RELATED WORK
+
+Numerous existing projects provide specialized systems for machine learning but are not closely related to our work. These include Apache SystemML (Ghoting et al., 2011), a high-level language and framework for writing and executing machine learning problems targeting Apache Spark, and TACO (Kjolstad et al., 2017), a $\mathrm { C } { + } { + }$ library for compiling and optimizing kernels that is more similar to Halide (Ragan-Kelley et al., 2013) than to our work. Our work treats the creation of neural networks as a compilers problem to be addressed using mature compiler techniques. SystemML does not consider this issue at all; TACO does use compiler optimization, but only at a very low level to generate individual kernels.
+
+Two projects closely related to this work are the TensorFlow XLA compiler and the NNVM compiler. The code representation in these frameworks is a “sea of nodes” representation, embedding control flow nodes and composite nodes in a data flow graph. To apply algorithmic differentiation on this IR requires non-standard processing. In contrast, our approach is designed from the start around the idea that a neural network (and its associated tensor computations) is itself a program, which is best optimized through robust application of mature techniques in a principled compilation pipeline. We represent tensor computation in static single assignment (SSA) form with control flow graph, and perform algorithmic differentiation, domain-specific optimizations, general-purpose optimizations, low-level optimizations, and code generation.
+
+XLA takes a similar approach to ours, transforming TensorFlow sub-graphs to XLA’s HLO graph and performing optimizations. Our intermediate representation is much more expressive than XLA’s by including modular IR components and general-purpose instructions; this enables our approach to support full-fledged DSLs including standalone compiled DSLs and perform more extensive optimizations such as inlining and interprocedual optimizations. Our approach also differs from XLA by representing composite functions such as min and max directly through primitive instructions such as compare and select, which enables us to apply generic AD, and by using SSA form with control flow graph, which allows for reusing battle-tested SSA optimization algorithms in the LLVM community. Importantly, our entire infrastructure was designed from the start around a robust compile-time framework for tensor DSLs, whereas XLA has been adapted around the existing TensorFlow infrastructure with a particular focus on hardware support for Google’s Tensor Processing Units (Jouppi et al., 2017).
+
+![](images/3c33c1e1b4e49d79cea6b0b96005ddd908e5cf9752dd02376466dc1917156439.jpg)  
+Figure 2: Compilation stages in the DLVM compilation pipeline.
+
+Where TVM and NNVM are built as a DSL and a graph library in Python with a $\mathrm { C } { + } { + }$ implementation, DLVM’s architecture is closer to LLVM and the Swift Intermediate Language (Groff & Lattner, 2015), having an IR file format and a full-fledged command line toolchain. More specifically, our work differs from NNVM and XLA in the design and presence of an IR that has a textual parsable format, a module/function/basic block hierarchy, custom type declarations and memory semantics. The textual IR enables robust unit testing via FileCheck, which is used extensively in LLVM and most LLVM-based compilers. Moreover, DLVM and its associated DSLs are implemented entirely in Swift, a safe systems programming language, and thus have an elegantly compact codebase and type-safe APIs.
+
+# 3 DLVM
+
+Deep Learning Virtual Machine (DLVM) is a compiler infrastructure designed for modern deep learning systems.1 DLVM is designed to apply a multi-stage compiler optimization strategy to both high-level linear algebra and low-level parallelism, perform domain-specific transformations, relieve the overhead in front-end languages, and serve as the host for research and development of DSLs for deep learning. The complete DLVM software stack, including sample front-end deep learning DSLs, is shown in Figure 1 on the preceding page.
+
+Figure 2 illustrates the major stages in the DLVM compilation pipeline. The DLVM compilation stages address algorithmic differentiation, domain-specific optimizations, general-purpose optimizations, and static code generation targeting a variety of compute architectures. The raw and optimizable stages allow constructs for high-level tensor operations and various high-level optimizations. The compute and schedule stages allow constructs for low-level array operations lowered from tensor operations in high-level stages, borrowing the design from Halide (Ragan-Kelley et al., 2013).
+
+The DLVM Intermediate Representation (IR) is the core language of the system. It uses static single assignment (SSA) form, control flow graphs, high-level types including a first-class tensor type, and a set of linear algebra operators combined with a general-purpose instruction set (see Table 1). The system enables a wide variety of domain-specific analyses and transformations, such as reverse-mode AD, AD checkpointing, algebra simplification and linear algebra fusion.
+
+To demonstrate how DLVM helps the development of domain-specific languages (DSLs), in Section 3.4 we present one prototypical staged DSL: NNKit. NNKit features safe and natural expression of tensor computation alongside the host program, and targets DLVM for differentiation, optimizations and static code generation.
+
+Table 1: This table illustrates a selection of the instructions in the DLVM virtual instruction set. The instruction set includes linear algebra operations such as tanh and dot in addition to control flow instructions such as branch.   
+
+<table><tr><td rowspan=1 colspan=1>Kind</td><td rowspan=1 colspan=2>Example</td></tr><tr><td rowspan=2 colspan=1>Element-wise unaryElement-wise binaryDot</td><td></td><td></td></tr><tr><td rowspan=1 colspan=1> dot %a:<10 x</td><td></td></tr><tr><td rowspan=2 colspan=1>ReduceTransposeSliceCompareData type cast</td><td></td><td></td></tr><tr><td rowspan=1 colspan=1>slice %a:</td><td></td></tr><tr><td rowspan=2 colspan=1>Function applicationBranchConditional branchShape cast</td><td rowspan=2 colspan=1>arpl</td><td rowspan=1 colspan=1>ly%</td></tr><tr><td rowspan=1 colspan=1>bran</td><td rowspan=1 colspan=1>nch</td></tr></table>
+
+# 3.1 DLVM CORE
+
+DLVM Core contains essential components for an optimizing compiler: IR, pass manager, and passes (see Figure 1 on page 2). The DLVM IR consists of a virtual instruction set, control flow graph and data flow representation. Passes are functions that traverse the intermediate representation of a program, either producing useful results as analyses of the program (analysis passes), or mutating the program for differentiation and optimizations (transform passes).
+
+# 3.1.1 A DOMAIN-SPECIFIC COMPILER INTERMEDIATE REPRESENTATION FOR DLVM
+
+Inspired by the LLVM IR (Lattner & Adve, 2004) and the Swift Intermediate Language (Groff & Lattner, 2015), DLVM IR is a graph-based, modular code representation, with both an in-memory format and a textual format. The code representation has a hierarchy of abstractions: module, function, basic block, and instruction. An instruction is the minimal unit of code that operates on values, which can be globals, function arguments or temporary virtual registers produced by instructions. Each module contains a collection of type definitions, global values and functions. Each function has a control flow graph formed by basic blocks and control flow edges. Each basic block contains an ordered list of instructions with data dependencies forming a directed acyclic graph.
+
+The DLVM IR has a high-level type system with tensor as a first-class type. The DLVM virtual instruction set includes domain-specific primitive math operators, as well as general-purpose instructions for memory management, control flow and function application. Domain-specific instructions include element-wise unary operators, such as tanh and negate, element-wise binary operators, such as add and power, and complex operators such as dot, transpose, and convolve. All element-wise binary operators support broadcasting. A sample of DLVM IR code is shown in Figure 3 on the next page.
+
+The DLVM instruction set does not include composite math functions such as softmax, sigmoid, min or max. All of these functions can be composed of primitive math instructions and control flow constructs. This design allows for the standard AD algorithm to be applied to any differentiable program, with no need for special handling of composite cases.
+
+# 3.1.2 DOMAIN-SPECIFIC COMPILER PASSES FOR DLVM
+
+DLVM has a full-fledged pass infrastructure, performing various analyses and two kinds of transformations: differentiation and optimization. Differentiation constructs function definitions from gradient declarations using adjoint code generation (see Section 3.1.3 below). Optimization is then performed on the resulting IR, maximizing the code performance. Optimizations include domainspecific optimizations, such as algebra simplification, linear algebra fusion, matrix multiplication reordering, and AD checkpointing, and traditional compiler optimizations.
+
+![](images/d717d7aa13932d973e32e917d093ebca23c6520956de73c54d87b779344714ea.jpg)  
+Figure 3: Example code in DLVM intermediate representation. Note that some functions are annotated as defining the gradient of another function with respect some or all arguments. The body of these gradient functions will be automatically generated.
+
+Since DLVM IR is aware of mathematical operators such as tanh and power, the algebra simplification pass can find and simplify certain mathematical operations that are expensive or redundant. For example, $x ^ { 2 }$ can be simplified to $x \odot x$ $\odot$ stands for element-wise multiplication), and $x ^ { 0 }$ can be simplified to constant 1. Matrix multiplication reordering is another classic optimization that minimizes the number of sub-operations in a chain of matrix multiplications with different dimensionality, based on matrix multiplication’s associativity.
+
+Since the DLVM optimizer is aware of linear algebra operations with static dimensionality, maximizing the performance by fusing verbose linear operations into a single matrix multiplication is beneficial as well. For example, it is very common to encounter expressions of the form $\mathbf { W } \mathbf { X } + \mathbf { b }$ When unoptimized, the matrix multiplication and the addition will be parallelized separately. Since launching compute kernels separately can be expensive, DLVM performs linear algebra fusion, which transforms subexpressions involving both matrix multiplication and element-wise operations into a single matrix multiplication instruction on padded tensors. Besides the simple pattern like an addition of matrix multiplication and a vector, we can apply the same approach to a polynomial of multiple matrix multiplications, turning the polynomial into a single matrix multiplication. For example, in a simple recurrent neural network (RNN), each cell of the recurrence is a feed forward neural network that takes two inputs: $\mathbf { x } _ { t }$ , the input local to the current timestep, and $\mathbf { h } _ { t }$ , the hidden state carried along the recurrence. The linear algebra fusion pass can simplify operations in $\mathbf { h } _ { t } = f ( \mathbf { W } \mathbf { x } _ { t - 1 } + \mathbf { U } \mathbf { h } _ { t - 1 } + \mathbf { b } )$ from two matrix multiplications and two additions into a single matrix multiplication. A more aggressive, interprocedural version of linear algebra fusion can optimize parameter passing and memory allocation, so that the entire concatenated matrix can be created and passed around in the first place without reallocation.
+
+# 3.1.3 ALGORITHMIC DIFFERENTIATION THROUGH ADJOINT CODE GENERATION
+
+Algorithmic differentiation (AD), also known as automatic differentiation, encompasses a family of a well-known techniques for algorithmically obtaining the derivatives of a function $f : \mathbf { x } \in \mathbb { R } ^ { n } $ $\mathbf { y } \in \mathbb { R } ^ { m }$ (Naumann, 2011). The function $f$ can be represented as a directed acyclic computation graph representing the composition of elementary computational operations for which the respective derivatives are well known. The partial derivative $\frac { \partial y _ { j } } { \partial x _ { i } }$ can be computed through recursive applications of the chain rule, either in the forward direction (corresponding to a bottom-up traversal of the computation graph) or in the backward direction (corresponding to a top-down traversal of the computation graph). The former approach, called forward-mode or tangent-mode AD, is used in some research communities, most commonly when $m \gg n$ (Goodfellow et al., 2016). The latter approach, which includes the back-propagation algorithm (Rumelhart et al., 1986) as a special case, is called reverse-mode or adjoint-mode AD, and encompasses the techniques most commonly used for training the weights in neural networks.
+
+In DLVM, the differentiation pass is responsible for performing reverse-mode AD. This pass is responsible for generating DLVM IR code that calculates the derivative of a differentiable function. A function is marked as being automatically differentiable via gradient declarations. A gradient declaration is a function in a module that is declared with its mathematical relation with another function in the module and no function body. The function $\mathsf { \Omega } \mathsf { \Omega } \mathsf { \Omega } \mathsf { \Omega } \mathsf { \Omega } \mathsf { \Omega } \mathsf { f o o \mathrm { - \mathsf { \Omega } \mathsf { { g r a d } } \Omega } }$ in Figure 3 is an example of such a function. Gradient declarations are configurable, e.g. specifying arguments to differentiate with respect to, keeping original outputs, and toggling seedability to accept back-propagated gradients. The differentiation pass, when applied, canonicalizes every gradient declaration in the module to a normal function definition with basic blocks and instructions. The canonicalization process first copies basic blocks and instructions from the original function to the new function body, and then applies adjoint code generation to the function. Unlike many of the existing deep learning frameworks, AD in DLVM is a source code transformation, not interpretation (operator overloading) over the same program. This makes the compiler able to perform optimizations on the gradient computation separately and enables higher order differentiation.
+
+Given a differentiable function $f ( \mathbf { x } _ { 1 } , \mathbf { x } _ { 2 } , \ldots , \mathbf { x } _ { n } )$ , this pass creates a new function that computes the Jacobian $\mathbf { J } _ { f }$ . This approach to AD has several advantages with respect to AD performed by operator overloading $/$ graph interpretation. Unlike operator overloading, the gradient function produced by AD is a standalone function that sits uniformly alongside other functions in an IR module, representationally unrelated to the original function. The generated function takes original inputs and produces a tuple of partial derivatives with respect to the inputs. In AD, not all values in the forward evaluation will necessarily be used to compute derivatives. In DLVM, unused operations can be easily eliminated by the aggressive dead code elimination pass in the compilation pipeline (see Section 3.1.4). In addition, an AD-specific optimization technique called checkpointing can further reduce memory consumption during gradient computation.
+
+AD in DLVM is configurable. The front-end can choose to differentiate a function with respect to selected arguments, to keep some of the outputs of the original function, to apply differentiation to a specific output when there are multiple return values, or to enable the function to accept backpropagated gradients (seeds) through function composition, all by gradient declarations. If the function returns multiple values in a tuple, the gradient declaration can also specify which tuple element to differentiate. Our approach to AD is implemented as a transformation from one function to another function. This approach also makes higher-order differentiation possible; this can be accomplished by declaring a higher-order gradient function that differentiates the original gradient function.
+
+# 3.1.4 GENERAL-PURPOSE OPTIMIZATIONS FOR DLVM
+
+General-purpose optimizations refer to traditional compiler optimizations applied to DLVM IR. These optimizations are important at the DLVM stage in the compilation pipeline, since linear algebra computation can be highly optimized or eliminated before they get lowered to LLVM IR which contain parallel execution and low-level information that prevent LLVM optimizations from identifying high-level patterns. Some of these optimizations are aggressive dead code elimination, common subexpression elimination, and sparse conditional constant propagation. Applying such optimizations on gradient computation is not feasible in other approaches to AD that use graph interpretation (operator overloading), because the forward pass and the backward pass are tied together in a single graph; mutating either evaluation pass will alter the semantics of the other.
+
+# 3.2 CODE GENERATION
+
+Two major design goals of DLVM are the ability to target multiple heterogenous parallel architectures from the same front-end DSL code (and corresponding DLVM IR), and the ability to perform aggressive optimizations on lowered programs. In order to attain these goals, DLVM code generation transforms DLVM IR into LLVM IR. LLVM is a robust and mature compiler infrastructure with multiple back-ends, including NVIDIA GPUs. Many high-level DLVM IR linear algebra instructions over tensors abstract lower-level operations. The DLVM compiler transforms the high-level DLVM IR into lower-level stages and ultimately into calls to BLAS and compute kernels in LLVM IR. Existing LLVM utilities are used to compile the generated LLVM IR to the final binary.
+
+In order to take full advantage of a variety of emerging heterogeneous parallel architectures, we plan for future versions of DLVM to target the IR of HPVM (Srivastava et al., 2016), a higherlevel heterogeneous compiler extension to LLVM IR that allows for transparent targeting of diverse architectures from a data flow graph.
+
+# 3.3 DLVM COMMAND LINE TOOLCHAIN
+
+The front-end software associated with each DSL (see Section 3.4) is responsible for generating a DLVM IR for a given source language program to be compiled. The DLVM compiler infrastructure itself is a compiler from DLVM IR to LLVM IR, therefore having a command line toolchain is necessary for verifying, transforming and compiling batches of DLVM IR files $( \star _ { } . \mathrm { d l } )$ . Unlike XLA and NNVM/TVM, which only provide a Python $/ \mathrm { C } { + + }$ interface to their users, DLVM provides a command line interface like any industry-standard compiler.
+
+The DLVM optimizer utility, dlopt, accepts $\star$ .dl IR files and applies user-specified optimization passes on them. The DLVM compiler driver, dlc, accepts $\star$ .dl IR files and performs user-specified tasks, such as verification, differentiation, optimization passes, stage lowering passes, and code generation; the driver invokes the DLVM core library to achieve these tasks. Because of having a textual format of the IR, the DLVM framework can easily make use of the LLVM Integrated Tester (lit) and FileCheck to perform robust unit testing. In future development, we plan to introduce a DLVM bitcode format for compact storage and high-throughput processing of DLVM code.
+
+# 3.4 NEURAL NETWORK DSLS
+
+Most of existing deep learning DSLs are embedded in a dynamically typed scripting language such as Python and Lua. While these scripting languages provide flexibility and a large number of libraries for scientific computing, they can act as a barrier between lightweight prototyping code and systematic production code. This barrier significantly reduces the reliability of ML software, resulting in suboptimal programming experience and unnecessarily effortful development cycles.
+
+In software engineering, a proven approach to tackle this problem is language and compiler technologies, starting from a language that is amenable to static analysis. A well-designed deep learning DSL should support the needs of deep learning software developers by providing a safe environment for rapid prototyping, while simultaneously generating highly efficient code for training and inference. DSLs in a scripting language can easily achieve rapid prototyping, but they are generally incapable of providing a safe environment with optimal performance. We believe that the best solution is DSLs embedded in a type-safe, type-inferring programming language that is both fast and easy to learn. In our initial release of DLVM, we provide one such DSL, both as a proof-of-concept and as a reference implementation that showcases the capabilities of DLVM as a platform for deep learning DSL development.
+
+NNKit is a staged DSL embedded in Swift, featuring natural expression of tensor computation alongside the host program without losing static analyses and optimizations on the tensor program. Inspired by Lightweight Modular Staging (Rompf & Odersky, 2010), NNKit leverages the static type system of Swift to guarantee type safety of the DSL. Tensor types are wrapped in $\mathrm { R e p } { < } \mathrm { T } >$ , meaning the representation of some computation that produces data of type T. Tensor operators overloaded for Rep are essentially AST builders for delayed evaluation. Instead of generating computation nodes at runtime and performing operator-overloading AD like PyTorch or TensorFlow Eager (Google Brain Team, 2017), NNKit tensor computations are staged once during the lifetime of the host program. At invocation time of staged functions, NNKit emits shape-specialized DLVM IR and leverages DLVM to perform AD, optimizations, and low-level code generation. A sample of Swift code using NNKit is shown in Figure 4.
+
+![](images/0d26f4d3b2eee12db38e5fe6c1e74f9f289abe5662e934db33064114cc501489.jpg)  
+Figure 4: Example code in Swift using NNKit, a staged DSL targeting DLVM.
+
+The NNKit just-in-time compiler has four important phases: The first phase, expression staging, produces an unshaped graph IR of the tensor computation. The second phase, shape specialization, prepares to generate statically shaped DLVM IR for staged functions when they are applied to shaped tensors. The third phase, lowering, generates DLVM IR and passes it through DLVM, producing a dynamic library containing a function symbol. The final phase, function reification, loads the binary and wraps the low-level function to a Swift function.
+
+We anticipate other existing deep learning frameworks, such as TensorFlow, could be adapted to use DLVM as a back-end to their tensor math DSLs.
+
+# 4 CONCLUSION
+
+The deep learning research community has a rich variety of available frameworks. While two existing projects have attempted a compilers approach to deep learning frameworks, and have respectively achieved good integration with existing systems (TensorFlow XLA) and good performance (NNVM $+ \mathrm { T V M } )$ , their design philosophies have not entirely followed established best practices in optimizing compiler design. While well intentioned, the remaining vast majority of other frameworks have failed to observe that the problem of front-end DSLs, algorithmic differentiation, and converting a neural network into efficient executable code is, at its core, a compilers problem. As a result, important issues of extensibility and optimization have been addressed in less than optimal fashion in such frameworks. Nevertheless, several such frameworks have achieved wide adoption. We believe that the principled application of optimizing compiler techniques will lead to substantial improvements in the tools available to deep learning researchers. DLVM and its associated front-end DSLs have a major role to play in this future. Our existing implementation supports reverse-mode AD in the core language, and utilizes LLVM to target NVIDIA GPUs. In our ongoing work, we plan to substantially increase the number of supported hardware architectures by utilizing HPVM as an additional back-end, and explore more advanced AD techniques such as mixing forward and reverse modes.
+
+# REFERENCES
+
+Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Józefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mané, Rajat Monga, Sherry Moore, Derek Gordon Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viégas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467.
+
+Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems. CoRR, abs/1512.01274, 2015. URL http://arxiv.org/ abs/1512.01274.
+
+Tianqi Chen, Thierry Moreau, Ziheng Jiang, and Haichen Shen. TVM: An end to end IR stack for deploying deep learning workloads on hardware platforms. http://tvmlang.org/2017/ 08/17/tvm-release-announcement.html, 2017.
+
+Ronan Collobert, Koray Kavukcuoglu, and Clément Farabet. Torch7: A Matlab-like environment for machine learning. In NIPS Big Learning Workshop: Algorithms, Systems, and Tools for Learning at Scale, December 2011.
+
+Amol Ghoting, Rajasekar Krishnamurthy, Edwin Pednault, Berthold Reinwald, Vikas Sindhwani, Shirish Tatikonda, Yuanyuan Tian, and Shivakumar Vaithyanathan. Systemml: Declarative machine learning on MapReduce. In Proceedings of the 2011 IEEE 27th International Conference on Data Engineering, ICDE ’11, pp. 231–242, Washington, DC, USA, 2011. IEEE Computer Society. ISBN 978-1-4244-8959-6. doi: 10.1109/ICDE.2011.5767930. URL http://dx.doi.org/ 10.1109/ICDE.2011.5767930.
+
+Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org.
+
+Google Brain Team. Eager Execution: An imperative, define-by-run interface to TensorFlow. 2017. URL https://research.googleblog.com/2017/10/ eager-execution-imperative-define-by.html.
+
+Joe Groff and Chris Lattner. Swift’s High-Level IR: A Case Study of Complementing LLVM IR with Language-Specific Optimization. 2015 LLVM Developers’ Meeting, 2015. URL http: //llvm.org/devmtg/2015-10/slides/GroffLattner-SILHighLevelIR.pdf.
+
+Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre-luc Cantin, Clifford Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir Ghaemmaghami, Rajendra Gottipati, William Gulland, Robert Hagmann, Richard C. Ho, Doug Hogberg, John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander Kaplan, Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law, Diemthu Le, Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana Maggiore, Maire Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy Nix, Thomas Norrie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Amir Salek, Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan Steinberg, Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle, Vijay Vasudevan, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter performance analysis of a tensor processing unit. CoRR, abs/1704.04760, 2017. URL http: //arxiv.org/abs/1704.04760.
+
+Fredrik Kjolstad, Shoaib Kamil, Stephen Chou, David Lugato, and Saman Amarasinghe. The tensor algebra compiler. Proc. ACM Program. Lang., 1(OOPSLA):77:1–77:29, October 2017. ISSN 2475-1421. doi: 10.1145/3133901. URL http://doi.acm.org/10.1145/3133901.
+
+Chris Lattner and Vikram Adve. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In Proceedings of the 2004 International Symposium on Code Generation and Optimization (CGO’04), Palo Alto, California, Mar 2004.
+
+Chris Leary and Todd Wang. XLA: TensorFlow, compiled! TensorFlow Dev Summit 2017, February 2017.
+
+Uwe Naumann. The Art of Differentiating Computer Programs. Society for Industrial and Applied Mathematics, 2011. doi: 10.1137/1.9781611972078. URL http://epubs.siam.org/doi/ abs/10.1137/1.9781611972078.
+
+NNVM. NNVM compiler: Open compiler for AI frameworks. http://tvmlang.org/2017/ 10/06/nnvm-compiler-announcement.html, 2017.
+
+PyTorch Development Team. Tensors and Dynamic neural networks in Python with strong GPU acceleration. 2016. URL http://pytorch.org.
+
+Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman Amarasinghe. Halide: A language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13, pp. 519–530, New York, NY, USA, 2013. ACM. ISBN 978-1-4503-2014-6. doi: 10.1145/2491956.2462176. URL http://doi.acm.org/10.1145/2491956.2462176.
+
+Tiark Rompf and Martin Odersky. Lightweight modular staging: A pragmatic approach to runtime code generation and compiled dsls. In Proceedings of the Ninth International Conference on Generative Programming and Component Engineering, GPCE ’10, pp. 127–136, New York, NY, USA, 2010. ACM. ISBN 978-1-4503-0154-1. doi: 10.1145/1868294.1868314. URL http://doi.acm.org/10.1145/1868294.1868314.
+
+David E. Rumelhart, James L. McClelland, and CORPORATE PDP Research Group (eds.). Parallel Distributed Processing: Explorations in the Microstructure of Cognition, Vol. 1: Foundations. MIT Press, Cambridge, MA, USA, 1986. ISBN 0-262-68053-X.
+
+Prakalp Srivastava, Maria Kotsifakou, and Vikram S. Adve. HPVM: A portable virtual instruction set for heterogeneous parallel systems. CoRR, abs/1611.00860, 2016. URL http://arxiv.org/ abs/1611.00860.

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

@@ -0,0 +1,919 @@
+[
+    {
+        "type": "text",
+        "text": "DLVM: A MODERN COMPILER INFRASTRUCTURE FOR DEEP LEARNING SYSTEMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Richard Wei   \nDepartments of Computer Science & Linguistics   \nUniversity of Illinois at Urbana-Champaign   \nUrbana, IL 61801   \nxwei12@illinois.edu   \nLane Schwartz   \nDepartment of Linguistics   \nUniversity of Illinois at Urbana-Champaign   \nUrbana, IL 61801   \nlanes@illinois.edu ",
+        "bbox": [
+            183,
+            169,
+            503,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            526,
+            170,
+            813,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Vikram Adve ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            261,
+            279,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Computer Science   \nUniversity of Illinois at Urbana-Champaign   \nUrbana, IL 61801   \nvadve@illinois.edu ",
+        "bbox": [
+            184,
+            276,
+            470,
+            330
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            367,
+            544,
+            382
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning software demands reliability and performance. However, many of the existing deep learning frameworks are software libraries that act as an unsafe DSL in Python and a computation graph interpreter. We present DLVM, a design and implementation of a compiler infrastructure with a linear algebra intermediate representation, algorithmic differentiation by adjoint code generation, domainspecific optimizations and a code generator targeting GPU via LLVM. Designed as a modern compiler infrastructure inspired by LLVM, DLVM is more modular and more generic than existing deep learning compiler frameworks, and supports tensor DSLs with high expressivity. With our prototypical staged DSL embedded in Swift, we argue that the DLVM system enables a form of modular, safe and performant frameworks for deep learning. ",
+        "bbox": [
+            233,
+            401,
+            766,
+            555
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            590,
+            336,
+            606
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Within the deep learning community, most current approaches to neural networks make use of high-level frameworks with a tensor domain-specific language (DSL) such as Torch (Collobert et al., 2011), TensorFlow (Abadi et al., 2016), PyTorch (PyTorch Development Team, 2016), and MXNet (Chen et al., 2015). Traditionally, developers would build a computation graph (or dynamically generate graph nodes) using a DSL and let the framework interpret the computation graph on parallel architectures such as NVIDIA GPUs. While using hand-tuned GPU subroutines usually yields the best performance for complex operators, advanced compiler techniques can be applied to simplify computation, merge high-level operators based on shaping conditions, and fuse compatible elementwise operators to a single kernel to minimize the latency between kernel launches. Recent projects, the TensorFlow XLA compiler (Leary & Wang, 2017) and the NNVM compiler (NNVM, 2017) including TVM (Chen et al., 2017), have begun to apply compiler techniques to deep learning systems, targeting LLVM (Lattner & Adve, 2004) and various back-ends to achieve good performance. However, their design and implementation have not entirely followed established best practices in widely-used compiler frameworks in the industry. ",
+        "bbox": [
+            174,
+            625,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Moreover, some frameworks use operator-overloading algorithmic differentiation (AD) to compute gradients, leaving the gradient computation unoptimizable. The other approach to AD, source code transformation, can produce more efficient code. While frameworks such as TensorFlow already perform AD as a graph transformation and apply various optimizations, their AD transformation is not designed as a transformation pass in the pipeline of their compiler framework, but as part of the DSL library. Making AD part of the compiler framework would greatly simplify the development of DSLs, achieving separation of concerns. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/849b709b69e101ea7ef26d6864d1b1e0eafec6758703952e4749d0cbe5bb8354.jpg",
+        "image_caption": [
+            "Figure 1: Software stack of the DLVM infrastructure. Blue components are the compiler framework. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            818,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We introduce DLVM, a new compiler infrastructure for deep learning systems that addresses shortcomings of existing deep learning frameworks. Our solution includes (1) a domain-specific intermediate representation specifically designed for tensor computation, (2) principled use of modern compiler optimization techniques to substantially simplify neural network computation, including algebra simplification, AD checkpointing, compute kernel fusion, and various traditional compiler optimizations, (3) code generation through a mature compiler infrastructure that allows for transparent targeting of various hardware, and (4) an embedded DSL that supports static analysis, type safety, and natural expression of tensor computation, and has a just-in-time (JIT) compiler targeting DLVM for AD, optimizations, and code generation. ",
+        "bbox": [
+            174,
+            410,
+            826,
+            535
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            344,
+            573
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Numerous existing projects provide specialized systems for machine learning but are not closely related to our work. These include Apache SystemML (Ghoting et al., 2011), a high-level language and framework for writing and executing machine learning problems targeting Apache Spark, and TACO (Kjolstad et al., 2017), a $\\mathrm { C } { + } { + }$ library for compiling and optimizing kernels that is more similar to Halide (Ragan-Kelley et al., 2013) than to our work. Our work treats the creation of neural networks as a compilers problem to be addressed using mature compiler techniques. SystemML does not consider this issue at all; TACO does use compiler optimization, but only at a very low level to generate individual kernels. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Two projects closely related to this work are the TensorFlow XLA compiler and the NNVM compiler. The code representation in these frameworks is a “sea of nodes” representation, embedding control flow nodes and composite nodes in a data flow graph. To apply algorithmic differentiation on this IR requires non-standard processing. In contrast, our approach is designed from the start around the idea that a neural network (and its associated tensor computations) is itself a program, which is best optimized through robust application of mature techniques in a principled compilation pipeline. We represent tensor computation in static single assignment (SSA) form with control flow graph, and perform algorithmic differentiation, domain-specific optimizations, general-purpose optimizations, low-level optimizations, and code generation. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            833
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "XLA takes a similar approach to ours, transforming TensorFlow sub-graphs to XLA’s HLO graph and performing optimizations. Our intermediate representation is much more expressive than XLA’s by including modular IR components and general-purpose instructions; this enables our approach to support full-fledged DSLs including standalone compiled DSLs and perform more extensive optimizations such as inlining and interprocedual optimizations. Our approach also differs from XLA by representing composite functions such as min and max directly through primitive instructions such as compare and select, which enables us to apply generic AD, and by using SSA form with control flow graph, which allows for reusing battle-tested SSA optimization algorithms in the LLVM community. Importantly, our entire infrastructure was designed from the start around a robust compile-time framework for tensor DSLs, whereas XLA has been adapted around the existing TensorFlow infrastructure with a particular focus on hardware support for Google’s Tensor Processing Units (Jouppi et al., 2017). ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c33c1e1b4e49d79cea6b0b96005ddd908e5cf9752dd02376466dc1917156439.jpg",
+        "image_caption": [
+            "Figure 2: Compilation stages in the DLVM compilation pipeline. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            98,
+            831,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            310,
+            825,
+            395
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Where TVM and NNVM are built as a DSL and a graph library in Python with a $\\mathrm { C } { + } { + }$ implementation, DLVM’s architecture is closer to LLVM and the Swift Intermediate Language (Groff & Lattner, 2015), having an IR file format and a full-fledged command line toolchain. More specifically, our work differs from NNVM and XLA in the design and presence of an IR that has a textual parsable format, a module/function/basic block hierarchy, custom type declarations and memory semantics. The textual IR enables robust unit testing via FileCheck, which is used extensively in LLVM and most LLVM-based compilers. Moreover, DLVM and its associated DSLs are implemented entirely in Swift, a safe systems programming language, and thus have an elegantly compact codebase and type-safe APIs. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            526
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 DLVM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            266,
+            564
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Deep Learning Virtual Machine (DLVM) is a compiler infrastructure designed for modern deep learning systems.1 DLVM is designed to apply a multi-stage compiler optimization strategy to both high-level linear algebra and low-level parallelism, perform domain-specific transformations, relieve the overhead in front-end languages, and serve as the host for research and development of DSLs for deep learning. The complete DLVM software stack, including sample front-end deep learning DSLs, is shown in Figure 1 on the preceding page. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Figure 2 illustrates the major stages in the DLVM compilation pipeline. The DLVM compilation stages address algorithmic differentiation, domain-specific optimizations, general-purpose optimizations, and static code generation targeting a variety of compute architectures. The raw and optimizable stages allow constructs for high-level tensor operations and various high-level optimizations. The compute and schedule stages allow constructs for low-level array operations lowered from tensor operations in high-level stages, borrowing the design from Halide (Ragan-Kelley et al., 2013). ",
+        "bbox": [
+            174,
+            671,
+            825,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The DLVM Intermediate Representation (IR) is the core language of the system. It uses static single assignment (SSA) form, control flow graphs, high-level types including a first-class tensor type, and a set of linear algebra operators combined with a general-purpose instruction set (see Table 1). The system enables a wide variety of domain-specific analyses and transformations, such as reverse-mode AD, AD checkpointing, algebra simplification and linear algebra fusion. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate how DLVM helps the development of domain-specific languages (DSLs), in Section 3.4 we present one prototypical staged DSL: NNKit. NNKit features safe and natural expression of tensor computation alongside the host program, and targets DLVM for differentiation, optimizations and static code generation. ",
+        "bbox": [
+            174,
+            839,
+            823,
+            895
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/20d98aab7a123e6c09753bfb3cc8dfb7035594771e0bb772d661ba37e0d7df18.jpg",
+        "table_caption": [
+            "Table 1: This table illustrates a selection of the instructions in the DLVM virtual instruction set. The instruction set includes linear algebra operations such as tanh and dot in addition to control flow instructions such as branch. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Kind</td><td rowspan=1 colspan=2>Example</td></tr><tr><td rowspan=2 colspan=1>Element-wise unaryElement-wise binaryDot</td><td></td><td></td></tr><tr><td rowspan=1 colspan=1> dot %a:<10 x</td><td></td></tr><tr><td rowspan=2 colspan=1>ReduceTransposeSliceCompareData type cast</td><td></td><td></td></tr><tr><td rowspan=1 colspan=1>slice %a:</td><td></td></tr><tr><td rowspan=2 colspan=1>Function applicationBranchConditional branchShape cast</td><td rowspan=2 colspan=1>arpl</td><td rowspan=1 colspan=1>ly%</td></tr><tr><td rowspan=1 colspan=1>bran</td><td rowspan=1 colspan=1>nch</td></tr></table>",
+        "bbox": [
+            173,
+            102,
+            828,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 DLVM CORE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            376,
+            308,
+            391
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "DLVM Core contains essential components for an optimizing compiler: IR, pass manager, and passes (see Figure 1 on page 2). The DLVM IR consists of a virtual instruction set, control flow graph and data flow representation. Passes are functions that traverse the intermediate representation of a program, either producing useful results as analyses of the program (analysis passes), or mutating the program for differentiation and optimizations (transform passes). ",
+        "bbox": [
+            174,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 A DOMAIN-SPECIFIC COMPILER INTERMEDIATE REPRESENTATION FOR DLVM",
+        "text_level": 1,
+        "bbox": [
+            174,
+            491,
+            774,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Inspired by the LLVM IR (Lattner & Adve, 2004) and the Swift Intermediate Language (Groff & Lattner, 2015), DLVM IR is a graph-based, modular code representation, with both an in-memory format and a textual format. The code representation has a hierarchy of abstractions: module, function, basic block, and instruction. An instruction is the minimal unit of code that operates on values, which can be globals, function arguments or temporary virtual registers produced by instructions. Each module contains a collection of type definitions, global values and functions. Each function has a control flow graph formed by basic blocks and control flow edges. Each basic block contains an ordered list of instructions with data dependencies forming a directed acyclic graph. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            628
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The DLVM IR has a high-level type system with tensor as a first-class type. The DLVM virtual instruction set includes domain-specific primitive math operators, as well as general-purpose instructions for memory management, control flow and function application. Domain-specific instructions include element-wise unary operators, such as tanh and negate, element-wise binary operators, such as add and power, and complex operators such as dot, transpose, and convolve. All element-wise binary operators support broadcasting. A sample of DLVM IR code is shown in Figure 3 on the next page. ",
+        "bbox": [
+            174,
+            636,
+            825,
+            733
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The DLVM instruction set does not include composite math functions such as softmax, sigmoid, min or max. All of these functions can be composed of primitive math instructions and control flow constructs. This design allows for the standard AD algorithm to be applied to any differentiable program, with no need for special handling of composite cases. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            796
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1.2 DOMAIN-SPECIFIC COMPILER PASSES FOR DLVM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            814,
+            576,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "DLVM has a full-fledged pass infrastructure, performing various analyses and two kinds of transformations: differentiation and optimization. Differentiation constructs function definitions from gradient declarations using adjoint code generation (see Section 3.1.3 below). Optimization is then performed on the resulting IR, maximizing the code performance. Optimizations include domainspecific optimizations, such as algebra simplification, linear algebra fusion, matrix multiplication reordering, and AD checkpointing, and traditional compiler optimizations. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d717d7aa13932d973e32e917d093ebca23c6520956de73c54d87b779344714ea.jpg",
+        "image_caption": [
+            "Figure 3: Example code in DLVM intermediate representation. Note that some functions are annotated as defining the gradient of another function with respect some or all arguments. The body of these gradient functions will be automatically generated. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            818,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since DLVM IR is aware of mathematical operators such as tanh and power, the algebra simplification pass can find and simplify certain mathematical operations that are expensive or redundant. For example, $x ^ { 2 }$ can be simplified to $x \\odot x$ $\\odot$ stands for element-wise multiplication), and $x ^ { 0 }$ can be simplified to constant 1. Matrix multiplication reordering is another classic optimization that minimizes the number of sub-operations in a chain of matrix multiplications with different dimensionality, based on matrix multiplication’s associativity. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            590
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Since the DLVM optimizer is aware of linear algebra operations with static dimensionality, maximizing the performance by fusing verbose linear operations into a single matrix multiplication is beneficial as well. For example, it is very common to encounter expressions of the form $\\mathbf { W } \\mathbf { X } + \\mathbf { b }$ When unoptimized, the matrix multiplication and the addition will be parallelized separately. Since launching compute kernels separately can be expensive, DLVM performs linear algebra fusion, which transforms subexpressions involving both matrix multiplication and element-wise operations into a single matrix multiplication instruction on padded tensors. Besides the simple pattern like an addition of matrix multiplication and a vector, we can apply the same approach to a polynomial of multiple matrix multiplications, turning the polynomial into a single matrix multiplication. For example, in a simple recurrent neural network (RNN), each cell of the recurrence is a feed forward neural network that takes two inputs: $\\mathbf { x } _ { t }$ , the input local to the current timestep, and $\\mathbf { h } _ { t }$ , the hidden state carried along the recurrence. The linear algebra fusion pass can simplify operations in $\\mathbf { h } _ { t } = f ( \\mathbf { W } \\mathbf { x } _ { t - 1 } + \\mathbf { U } \\mathbf { h } _ { t - 1 } + \\mathbf { b } )$ from two matrix multiplications and two additions into a single matrix multiplication. A more aggressive, interprocedural version of linear algebra fusion can optimize parameter passing and memory allocation, so that the entire concatenated matrix can be created and passed around in the first place without reallocation. ",
+        "bbox": [
+            173,
+            598,
+            825,
+            819
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1.3 ALGORITHMIC DIFFERENTIATION THROUGH ADJOINT CODE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            743,
+            856
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithmic differentiation (AD), also known as automatic differentiation, encompasses a family of a well-known techniques for algorithmically obtaining the derivatives of a function $f : \\mathbf { x } \\in \\mathbb { R } ^ { n } $ $\\mathbf { y } \\in \\mathbb { R } ^ { m }$ (Naumann, 2011). The function $f$ can be represented as a directed acyclic computation graph representing the composition of elementary computational operations for which the respective derivatives are well known. The partial derivative $\\frac { \\partial y _ { j } } { \\partial x _ { i } }$ can be computed through recursive applications of the chain rule, either in the forward direction (corresponding to a bottom-up traversal of the computation graph) or in the backward direction (corresponding to a top-down traversal of the computation graph). The former approach, called forward-mode or tangent-mode AD, is used in some research communities, most commonly when $m \\gg n$ (Goodfellow et al., 2016). The latter approach, which includes the back-propagation algorithm (Rumelhart et al., 1986) as a special case, is called reverse-mode or adjoint-mode AD, and encompasses the techniques most commonly used for training the weights in neural networks. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            101,
+            825,
+            217
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In DLVM, the differentiation pass is responsible for performing reverse-mode AD. This pass is responsible for generating DLVM IR code that calculates the derivative of a differentiable function. A function is marked as being automatically differentiable via gradient declarations. A gradient declaration is a function in a module that is declared with its mathematical relation with another function in the module and no function body. The function $\\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { f o o \\mathrm { - \\mathsf { \\Omega } \\mathsf { { g r a d } } \\Omega } }$ in Figure 3 is an example of such a function. Gradient declarations are configurable, e.g. specifying arguments to differentiate with respect to, keeping original outputs, and toggling seedability to accept back-propagated gradients. The differentiation pass, when applied, canonicalizes every gradient declaration in the module to a normal function definition with basic blocks and instructions. The canonicalization process first copies basic blocks and instructions from the original function to the new function body, and then applies adjoint code generation to the function. Unlike many of the existing deep learning frameworks, AD in DLVM is a source code transformation, not interpretation (operator overloading) over the same program. This makes the compiler able to perform optimizations on the gradient computation separately and enables higher order differentiation. ",
+        "bbox": [
+            173,
+            223,
+            825,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Given a differentiable function $f ( \\mathbf { x } _ { 1 } , \\mathbf { x } _ { 2 } , \\ldots , \\mathbf { x } _ { n } )$ , this pass creates a new function that computes the Jacobian $\\mathbf { J } _ { f }$ . This approach to AD has several advantages with respect to AD performed by operator overloading $/$ graph interpretation. Unlike operator overloading, the gradient function produced by AD is a standalone function that sits uniformly alongside other functions in an IR module, representationally unrelated to the original function. The generated function takes original inputs and produces a tuple of partial derivatives with respect to the inputs. In AD, not all values in the forward evaluation will necessarily be used to compute derivatives. In DLVM, unused operations can be easily eliminated by the aggressive dead code elimination pass in the compilation pipeline (see Section 3.1.4). In addition, an AD-specific optimization technique called checkpointing can further reduce memory consumption during gradient computation. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            564
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "AD in DLVM is configurable. The front-end can choose to differentiate a function with respect to selected arguments, to keep some of the outputs of the original function, to apply differentiation to a specific output when there are multiple return values, or to enable the function to accept backpropagated gradients (seeds) through function composition, all by gradient declarations. If the function returns multiple values in a tuple, the gradient declaration can also specify which tuple element to differentiate. Our approach to AD is implemented as a transformation from one function to another function. This approach also makes higher-order differentiation possible; this can be accomplished by declaring a higher-order gradient function that differentiates the original gradient function. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1.4 GENERAL-PURPOSE OPTIMIZATIONS FOR DLVM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            756,
+            568,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "General-purpose optimizations refer to traditional compiler optimizations applied to DLVM IR. These optimizations are important at the DLVM stage in the compilation pipeline, since linear algebra computation can be highly optimized or eliminated before they get lowered to LLVM IR which contain parallel execution and low-level information that prevent LLVM optimizations from identifying high-level patterns. Some of these optimizations are aggressive dead code elimination, common subexpression elimination, and sparse conditional constant propagation. Applying such optimizations on gradient computation is not feasible in other approaches to AD that use graph interpretation (operator overloading), because the forward pass and the backward pass are tied together in a single graph; mutating either evaluation pass will alter the semantics of the other. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 CODE GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            349,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Two major design goals of DLVM are the ability to target multiple heterogenous parallel architectures from the same front-end DSL code (and corresponding DLVM IR), and the ability to perform aggressive optimizations on lowered programs. In order to attain these goals, DLVM code generation transforms DLVM IR into LLVM IR. LLVM is a robust and mature compiler infrastructure with multiple back-ends, including NVIDIA GPUs. Many high-level DLVM IR linear algebra instructions over tensors abstract lower-level operations. The DLVM compiler transforms the high-level DLVM IR into lower-level stages and ultimately into calls to BLAS and compute kernels in LLVM IR. Existing LLVM utilities are used to compile the generated LLVM IR to the final binary. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            241
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In order to take full advantage of a variety of emerging heterogeneous parallel architectures, we plan for future versions of DLVM to target the IR of HPVM (Srivastava et al., 2016), a higherlevel heterogeneous compiler extension to LLVM IR that allows for transparent targeting of diverse architectures from a data flow graph. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            304
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 DLVM COMMAND LINE TOOLCHAIN ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            320,
+            467,
+            333
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The front-end software associated with each DSL (see Section 3.4) is responsible for generating a DLVM IR for a given source language program to be compiled. The DLVM compiler infrastructure itself is a compiler from DLVM IR to LLVM IR, therefore having a command line toolchain is necessary for verifying, transforming and compiling batches of DLVM IR files $( \\star _ { } . \\mathrm { d l } )$ . Unlike XLA and NNVM/TVM, which only provide a Python $/ \\mathrm { C } { + + }$ interface to their users, DLVM provides a command line interface like any industry-standard compiler. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The DLVM optimizer utility, dlopt, accepts $\\star$ .dl IR files and applies user-specified optimization passes on them. The DLVM compiler driver, dlc, accepts $\\star$ .dl IR files and performs user-specified tasks, such as verification, differentiation, optimization passes, stage lowering passes, and code generation; the driver invokes the DLVM core library to achieve these tasks. Because of having a textual format of the IR, the DLVM framework can easily make use of the LLVM Integrated Tester (lit) and FileCheck to perform robust unit testing. In future development, we plan to introduce a DLVM bitcode format for compact storage and high-throughput processing of DLVM code. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            534
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 NEURAL NETWORK DSLS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            393,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Most of existing deep learning DSLs are embedded in a dynamically typed scripting language such as Python and Lua. While these scripting languages provide flexibility and a large number of libraries for scientific computing, they can act as a barrier between lightweight prototyping code and systematic production code. This barrier significantly reduces the reliability of ML software, resulting in suboptimal programming experience and unnecessarily effortful development cycles. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            646
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In software engineering, a proven approach to tackle this problem is language and compiler technologies, starting from a language that is amenable to static analysis. A well-designed deep learning DSL should support the needs of deep learning software developers by providing a safe environment for rapid prototyping, while simultaneously generating highly efficient code for training and inference. DSLs in a scripting language can easily achieve rapid prototyping, but they are generally incapable of providing a safe environment with optimal performance. We believe that the best solution is DSLs embedded in a type-safe, type-inferring programming language that is both fast and easy to learn. In our initial release of DLVM, we provide one such DSL, both as a proof-of-concept and as a reference implementation that showcases the capabilities of DLVM as a platform for deep learning DSL development. ",
+        "bbox": [
+            174,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "NNKit is a staged DSL embedded in Swift, featuring natural expression of tensor computation alongside the host program without losing static analyses and optimizations on the tensor program. Inspired by Lightweight Modular Staging (Rompf & Odersky, 2010), NNKit leverages the static type system of Swift to guarantee type safety of the DSL. Tensor types are wrapped in $\\mathrm { R e p } { < } \\mathrm { T } >$ , meaning the representation of some computation that produces data of type T. Tensor operators overloaded for Rep are essentially AST builders for delayed evaluation. Instead of generating computation nodes at runtime and performing operator-overloading AD like PyTorch or TensorFlow Eager (Google Brain Team, 2017), NNKit tensor computations are staged once during the lifetime of the host program. At invocation time of staged functions, NNKit emits shape-specialized DLVM IR and leverages DLVM to perform AD, optimizations, and low-level code generation. A sample of Swift code using NNKit is shown in Figure 4. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d26f4d3b2eee12db38e5fe6c1e74f9f289abe5662e934db33064114cc501489.jpg",
+        "image_caption": [
+            "Figure 4: Example code in Swift using NNKit, a staged DSL targeting DLVM. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            103,
+            821,
+            438
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            502,
+            825,
+            531
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The NNKit just-in-time compiler has four important phases: The first phase, expression staging, produces an unshaped graph IR of the tensor computation. The second phase, shape specialization, prepares to generate statically shaped DLVM IR for staged functions when they are applied to shaped tensors. The third phase, lowering, generates DLVM IR and passes it through DLVM, producing a dynamic library containing a function symbol. The final phase, function reification, loads the binary and wraps the low-level function to a Swift function. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            622
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We anticipate other existing deep learning frameworks, such as TensorFlow, could be adapted to use DLVM as a back-end to their tensor math DSLs. ",
+        "bbox": [
+            173,
+            628,
+            823,
+            657
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            318,
+            696
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The deep learning research community has a rich variety of available frameworks. While two existing projects have attempted a compilers approach to deep learning frameworks, and have respectively achieved good integration with existing systems (TensorFlow XLA) and good performance (NNVM $+ \\mathrm { T V M } )$ , their design philosophies have not entirely followed established best practices in optimizing compiler design. While well intentioned, the remaining vast majority of other frameworks have failed to observe that the problem of front-end DSLs, algorithmic differentiation, and converting a neural network into efficient executable code is, at its core, a compilers problem. As a result, important issues of extensibility and optimization have been addressed in less than optimal fashion in such frameworks. Nevertheless, several such frameworks have achieved wide adoption. We believe that the principled application of optimizing compiler techniques will lead to substantial improvements in the tools available to deep learning researchers. DLVM and its associated front-end DSLs have a major role to play in this future. Our existing implementation supports reverse-mode AD in the core language, and utilizes LLVM to target NVIDIA GPUs. In our ongoing work, we plan to substantially increase the number of supported hardware architectures by utilizing HPVM as an additional back-end, and explore more advanced AD techniques such as mixing forward and reverse modes. ",
+        "bbox": [
+            173,
+            715,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Józefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mané, Rajat Monga, Sherry Moore, Derek Gordon Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A. Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viégas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL http://arxiv.org/abs/1603.04467. ",
+        "bbox": [
+            176,
+            126,
+            826,
+            252
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu, Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for heterogeneous distributed systems. CoRR, abs/1512.01274, 2015. URL http://arxiv.org/ abs/1512.01274. ",
+        "bbox": [
+            174,
+            262,
+            826,
+            318
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Thierry Moreau, Ziheng Jiang, and Haichen Shen. TVM: An end to end IR stack for deploying deep learning workloads on hardware platforms. http://tvmlang.org/2017/ 08/17/tvm-release-announcement.html, 2017. ",
+        "bbox": [
+            176,
+            329,
+            825,
+            372
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ronan Collobert, Koray Kavukcuoglu, and Clément Farabet. Torch7: A Matlab-like environment for machine learning. In NIPS Big Learning Workshop: Algorithms, Systems, and Tools for Learning at Scale, December 2011. ",
+        "bbox": [
+            173,
+            382,
+            825,
+            425
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Amol Ghoting, Rajasekar Krishnamurthy, Edwin Pednault, Berthold Reinwald, Vikas Sindhwani, Shirish Tatikonda, Yuanyuan Tian, and Shivakumar Vaithyanathan. Systemml: Declarative machine learning on MapReduce. In Proceedings of the 2011 IEEE 27th International Conference on Data Engineering, ICDE ’11, pp. 231–242, Washington, DC, USA, 2011. IEEE Computer Society. ISBN 978-1-4244-8959-6. doi: 10.1109/ICDE.2011.5767930. URL http://dx.doi.org/ 10.1109/ICDE.2011.5767930. ",
+        "bbox": [
+            174,
+            435,
+            826,
+            520
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http: //www.deeplearningbook.org. ",
+        "bbox": [
+            171,
+            530,
+            825,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Google Brain Team. Eager Execution: An imperative, define-by-run interface to TensorFlow. 2017. URL https://research.googleblog.com/2017/10/ eager-execution-imperative-define-by.html. ",
+        "bbox": [
+            174,
+            569,
+            826,
+            613
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joe Groff and Chris Lattner. Swift’s High-Level IR: A Case Study of Complementing LLVM IR with Language-Specific Optimization. 2015 LLVM Developers’ Meeting, 2015. URL http: //llvm.org/devmtg/2015-10/slides/GroffLattner-SILHighLevelIR.pdf. ",
+        "bbox": [
+            174,
+            622,
+            826,
+            665
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa, Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre-luc Cantin, Clifford Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir Ghaemmaghami, Rajendra Gottipati, William Gulland, Robert Hagmann, Richard C. Ho, Doug Hogberg, John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander Kaplan, Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law, Diemthu Le, Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana Maggiore, Maire Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy Nix, Thomas Norrie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Amir Salek, Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan Steinberg, Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle, Vijay Vasudevan, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter performance analysis of a tensor processing unit. CoRR, abs/1704.04760, 2017. URL http: //arxiv.org/abs/1704.04760. ",
+        "bbox": [
+            178,
+            676,
+            826,
+            869
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fredrik Kjolstad, Shoaib Kamil, Stephen Chou, David Lugato, and Saman Amarasinghe. The tensor algebra compiler. Proc. ACM Program. Lang., 1(OOPSLA):77:1–77:29, October 2017. ISSN 2475-1421. doi: 10.1145/3133901. URL http://doi.acm.org/10.1145/3133901. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chris Lattner and Vikram Adve. LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation. In Proceedings of the 2004 International Symposium on Code Generation and Optimization (CGO’04), Palo Alto, California, Mar 2004. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chris Leary and Todd Wang. XLA: TensorFlow, compiled! TensorFlow Dev Summit 2017, February 2017. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Uwe Naumann. The Art of Differentiating Computer Programs. Society for Industrial and Applied Mathematics, 2011. doi: 10.1137/1.9781611972078. URL http://epubs.siam.org/doi/ abs/10.1137/1.9781611972078. ",
+        "bbox": [
+            174,
+            193,
+            823,
+            234
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "NNVM. NNVM compiler: Open compiler for AI frameworks. http://tvmlang.org/2017/ 10/06/nnvm-compiler-announcement.html, 2017. ",
+        "bbox": [
+            174,
+            244,
+            821,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "PyTorch Development Team. Tensors and Dynamic neural networks in Python with strong GPU acceleration. 2016. URL http://pytorch.org. ",
+        "bbox": [
+            176,
+            281,
+            821,
+            311
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman Amarasinghe. Halide: A language and compiler for optimizing parallelism, locality, and recomputation in image processing pipelines. In Proceedings of the 34th ACM SIGPLAN Conference on Programming Language Design and Implementation, PLDI ’13, pp. 519–530, New York, NY, USA, 2013. ACM. ISBN 978-1-4503-2014-6. doi: 10.1145/2491956.2462176. URL http://doi.acm.org/10.1145/2491956.2462176. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            404
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tiark Rompf and Martin Odersky. Lightweight modular staging: A pragmatic approach to runtime code generation and compiled dsls. In Proceedings of the Ninth International Conference on Generative Programming and Component Engineering, GPCE ’10, pp. 127–136, New York, NY, USA, 2010. ACM. ISBN 978-1-4503-0154-1. doi: 10.1145/1868294.1868314. URL http://doi.acm.org/10.1145/1868294.1868314. ",
+        "bbox": [
+            174,
+            412,
+            825,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David E. Rumelhart, James L. McClelland, and CORPORATE PDP Research Group (eds.). Parallel Distributed Processing: Explorations in the Microstructure of Cognition, Vol. 1: Foundations. MIT Press, Cambridge, MA, USA, 1986. ISBN 0-262-68053-X. ",
+        "bbox": [
+            176,
+            491,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prakalp Srivastava, Maria Kotsifakou, and Vikram S. Adve. HPVM: A portable virtual instruction set for heterogeneous parallel systems. CoRR, abs/1611.00860, 2016. URL http://arxiv.org/ abs/1611.00860. ",
+        "bbox": [
+            174,
+            544,
+            826,
+            587
+        ],
+        "page_idx": 9
+    }
+]