Add files using upload-large-folder tool

parse/train/3-GCM92yaB3/3-GCM92yaB3.md

@@ -0,0 +1,331 @@
+# The Unbalanced Gromov Wasserstein Distance: Conic Formulation and Relaxation
+
+Thibault Séjourné Ecole Normale Supérieure, DMA, PSL thibault.sejourne@ens.fr
+
+François-Xavier Vialard Université Gustave Eiffel francois-xavier.vialard@u-pem.fr
+
+Gabriel Peyré Ecole Normale Supérieure, DMA, CNRS, PSL gabriel.peyre@ens.fr
+
+# Abstract
+
+Comparing metric measure spaces (i.e. a metric space endowed with a probability distribution) is at the heart of many machine learning problems. The most popular distance between such metric measure spaces is the Gromov-Wasserstein (GW) distance, which is the solution of a quadratic assignment problem. The GW distance is however limited to the comparison of metric measure spaces endowed with a probability distribution. To alleviate this issue, we introduce two Unbalanced Gromov-Wasserstein formulations: a distance and a more tractable upper-bounding relaxation. They both allow the comparison of metric spaces equipped with arbitrary positive measures up to isometries. The first formulation is a positive and definite divergence based on a relaxation of the mass conservation constraint using a novel type of quadratically-homogeneous divergence. This divergence works hand in hand with the entropic regularization approach which is popular to solve large scale optimal transport problems. We show that the underlying non-convex optimization problem can be efficiently tackled using a highly parallelizable and GPU-friendly iterative scheme. The second formulation is a distance between mm-spaces up to isometries based on a conic lifting. Lastly, we provide numerical experiments on synthetic examples and domain adaptation data with a Positive-Unlabeled learning task to highlight the salient features of the unbalanced divergence and its potential applications in ML.
+
+# 1 Introduction
+
+Comparing data distributions on different metric spaces is a basic problem in machine learning. This class of problems is for instance at the heart of surfaces [Bronstein et al., 2006] or graph matching $\mathrm { [ X u }$ et al., 2019] (equipping the surface or graph with its associated geodesic distance), regression problems in quantum chemistry [Gilmer et al., 2017] (viewing the molecules as distributions of points in $\mathbb { R } ^ { 3 }$ ) and natural language processing [Grave et al., 2019, Alvarez-Melis and Jaakkola, 2018] (where texts in different languages are embedded as points distributions in different vector spaces).
+
+Metric measure spaces. The mathematical way to formalize these problems is to model the data as metric measure spaces (mm-spaces). A mm-space is denoted as $\mathbf { \bar { \boldsymbol { X } } } = ( X , d , \mu )$ where $X$ is a complete separable set endowed with a distance $d$ and a positive Borel measure $\mu \in { \mathcal { M } } _ { + } ( X )$ . For instance, if $\bar { X } = ( x _ { i } ) _ { i }$ is a finite set of points, then $\mu = \bar { \Sigma _ { i } } m _ { i } \delta _ { x _ { i } }$ (here $\delta _ { x _ { i } }$ is the Dirac mass at $x _ { i }$ ) is simply a set of positive weights $m _ { i } = \dot { \mu } ( \{ x _ { i } \} ) \ge \dot { 0 }$ associated to each point $x _ { i }$ , which accounts for its mass or importance. For instance, setting some $m _ { i }$ to 0 is equivalent to removing the point $x _ { i }$ . We refer to Sturm [2012] for a mathematical account on the theory of mm-spaces. In all the applications highlighted above, it makes sense to perform the comparisons up to isometric transformations of the data. Two mm-spaces $\mathcal { X } = ( X , d _ { X } , \mu )$ and $\mathcal { V } = ( Y , d _ { Y } , \nu )$ are considered to be equal (denoted $\mathcal { X } \sim \mathcal { V }$ ) if they are isometric, meaning that there is a bijection $\psi : \mathrm { s p t } ( \mu ) \to \mathrm { s p t } ( \nu )$ (where $\operatorname { s p t } ( \mu )$ is the support of $\mu$ ) such that $d _ { X } ( x , y ) { \overset { \cdot } { = } } d _ { Y } ( \psi ( x ) , \psi ( y ) )$ and $\psi _ { \sharp } \mu = \nu$ . Here $\psi _ { \sharp }$ is the push-forward operator, so that $\psi _ { \sharp } \mu = \nu$ is equivalent to imposing $\nu ( A ) = \mu ( \psi ^ { - 1 } ( A ) )$ for any set $A \subset Y$ . For discrete spaces where $\begin{array} { r } { \mu = \sum _ { i } m _ { i } \delta _ { x _ { i } } } \end{array}$ , then one should have $\begin{array} { r } { \nu = \psi _ { \sharp } \mu = \sum _ { i } m _ { i } \delta _ { \psi ( x _ { i } ) } , } \end{array}$ . As highlighted by Mémoli [2011], considering mm-spaces up to isometry is a powerful way to formalize and analyze a wide variety of problems such as matching, regression and classification of distributions of points belonging to different spaces. Most often, the objects of interest come with a natural distance such as an intrinsic or extrinsic distance and the uniform measure is the usual choice to make mm-spaces widely applicable. The key to unlock all these problems is the computation of a distance between mm-spaces up to isometry. So far, existing distances (reviewed below) assume that $\mu$ is a probability distribution, i.e. $\mu ( X ) = 1$ . This constraint is not natural and sometimes problematic for most of the practical applications to machine learning. The goal of this paper is to alleviate this restriction. We define for the first time a class of distances between unbalanced metric measure spaces, these distances being upper-bounded by divergences which can be approximated by an efficient numerical scheme.
+
+Csiszár divergences The simplest case is when $X = Y$ and one simply ignores the underlying metric. One can then use Csiszár divergences (or $\varphi$ -divergences), which perform a pointwise comparison (in contrast with optimal transport distances, which perform a displacement comparison). It is defined using an entropy function $\varphi : \mathbb { R } _ { + } \to [ 0 , + \infty ]$ , which is a convex, lower semi-continuous, positive function with $\varphi ( 1 ) = 0$ . The Csiszár $\varphi$ -divergence reads $\begin{array} { r } { \mathbf { D } _ { \varphi } ( \mu | \nu ) \triangleq \int _ { X } \varphi \big ( \frac { \mathrm { d } \mu } { \mathrm { d } \nu } \big ) \mathrm { d } \nu + } \end{array}$ $\varphi _ { \infty } ^ { \prime } \int _ { X } \mathrm { d } \mu ^ { \perp }$ , where $\begin{array} { r } { \mu = \frac { \mathrm { d } \mu } { \mathrm { d } \nu } \nu + \mu ^ { \perp } } \end{array}$ is called the Radon-Nikodym or the Lebesgue decomposition of $\mu$ with respect to $\nu$ and $\begin{array} { r } { \varphi _ { \infty } ^ { \prime } = \operatorname* { l i m } _ { r \to \infty } \varphi ( r ) / r \in \mathbb { R } \cup \{ + \infty \} } \end{array}$ is called the recession constant. This divergence $\mathrm { D } _ { \varphi }$ is convex, positive, 1-homogeneous and weak\* lower-semicontinuous, see Liero et al. [2015] for details. Particular instances of $\varphi$ -divergences are Kullback-Leibler (KL) for $\varphi ( r ) =$ $r \log ( r ) - r + 1$ (note that $\varphi _ { \infty } ^ { \prime } = \infty ,$ ) and Total Variation (TV) for $\varphi ( r ) = | r - 1 |$ .
+
+Balanced and unbalanced optimal transport. If the common embedding space $X$ is equipped with a distance $d ( x , y )$ , one can use more elaborated methods such as optimal transport (OT) distances, which are computed by solving convex optimization problems. This type of methods has proven useful for ML problems as diverse as domain adaptation [Courty et al., 2014], supervised learning over histograms [Frogner et al., 2015] and unsupervised learning of generative models [Arjovsky et al., 2017]. In this case, the extension from probability distributions to arbitrary positive measures $( \mu , \nu ) \in$ $\mathcal { M } _ { + } ( X ) ^ { 2 }$ is now well understood and corresponds to the theory of unbalanced OT. Following Liero et al. [2015], Chizat et al. [2018a], a family of unbalanced Wasserstein distances is defined by solving
+
+$$
+\mathrm { U W } ( \mu , \nu ) ^ { q } \triangleq \operatorname* { i n f } _ { \pi \in \mathcal { M } ( X \times X ) } \int \lambda ( d ( x , y ) ) \mathrm { d } \pi ( x , y ) +  { \mathbf { D } _ { \varphi } } ( \pi _ { 1 } | \mu ) +  { \mathbf { D } _ { \varphi } } ( \pi _ { 2 } | \mu ) .
+$$
+
+Here $( \pi _ { 1 } , \pi _ { 2 } )$ are the two marginals of the joint distribution $\pi$ , defined by $\pi _ { 1 } ( A ) = \pi ( A \times Y )$ for $A \subset X$ . The mapping $\lambda : \mathbb { R } ^ { + }  \mathbb { R }$ and exponent $q \geq 1$ should be chosen wisely to ensure for instance that UW defines a distance (see Section 2.2.1). It is frequent to take $\rho \mathrm { D } _ { \varphi }$ instead of $\mathrm { D } _ { \varphi }$ (i.e. take $\psi = \rho \varphi ,$ ) to adjust the strength of the marginals’ penalization. Balanced OT is retrieved with the convex indicator $\varphi = \iota _ { \{ 1 \} }$ (i.e. $\varphi ( 1 ) = 0$ and $\varphi ( x ) = + \infty$ otherwise) or by taking the limit $\rho  + \infty$ , which enforces $\pi _ { 1 } = \mu$ and $\pi _ { 2 } = \nu$ . When $0 < \rho < + \infty$ , unbalanced OT operates a trade-off between transportation and creation of mass, which is crucial to be robust to outliers in the data and to cope with mass variations in the modes of the distributions. For supervised tasks, the value of $\rho$ should be cross-validated to obtain the best performances. Its use is gaining popularity in applications, such as medical imaging registration [Feydy et al., 2019a], videos [Lee et al., 2019], generative learning [Balaji et al., 2020] and gradient flow to train neural networks [Chizat and Bach, 2018, Rotskoff et al., 2019]. Furthermore, existing efficient algorithms for balanced OT extend to this unbalanced problem. In particular Sinkhorn’s iterations, introduced in ML for balanced OT by Cuturi [2013], extend to unbalanced OT [Chizat et al., 2018b, Séjourné et al., 2019], as detailed in Section 3.
+
+The Gromov-Wasserstein distance and its applications. The Gromov-Wasserstein (GW) distance [Mémoli, 2011, Sturm, 2012] generalizes the notion of OT to the setting of mm-spaces up to isometries. It replaces the linear cost $\textstyle \int \lambda ( d ) \mathrm { d } \pi$ of OT by a quadratic function. It reads
+
+$$
+\mathbf { G W } ( \mathcal { X } , \mathcal { Y } ) ^ { q } \triangleq \operatorname* { m i n } _ { \pi \in \mathcal { M } _ { + } ( X \times Y ) } \left\{ \int \lambda \big ( | d _ { X } ( x , x ^ { \prime } ) - d _ { Y } ( y , y ^ { \prime } ) | \big ) \mathrm { d } \pi ( x , y ) \mathrm { d } \pi ( x ^ { \prime } , y ^ { \prime } ) : \operatorname { \Lambda } _ { \pi _ { 2 } = \nu } ^ { \pi _ { 1 } = \mu } \right\} .
+$$
+
+It is proved in Mémoli [2011], Sturm [2012] that GW defines with $\lambda ( t ) = t ^ { q }$ a distance up to isometries on balanced mm-spaces (i.e. the measures are probability distributions). The GW distance is applied successfully in natural language processing for unsupervised translation learning [Grave et al., 2019, Alvarez-Melis and Jaakkola, 2018], in generative learning for objects lying in spaces of different dimensions [Bunne et al., 2019] and to build VAE for graphs [Xu et al., 2020]. It has been adapted for domain adaptation over different spaces [Redko et al., 2020]. It is also a relevant distance to compute barycenters between graphs or shapes [Vayer et al., 2018, Chowdhury and Needham, 2020]. When $( \mathcal { X } , \mathcal { Y } )$ are Euclidean spaces, this distance compares distributions up to rigid isometry, and is closely related (but not equal) to metrics defined by procrustes analysis [Grave et al., 2019, Alvarez-Melis et al., 2019]. The problem (2) is non convex because the quadratic form $\begin{array} { r } { \int \lambda ( | d _ { X } - d _ { Y } | ) \mathrm { d } \pi \otimes \pi } \end{array}$ is not positive in general. It is in fact closely related to quadratic assignment problems [Burkard et al., 1998], which are used for graph matching problems, and are known to be NP-hard in general. Nevertheless, non-convex optimization methods have been shown to be successful in practice to use GW distances for ML problems. This includes for instance alternating minimization [Mémoli, 2011, Redko et al., 2020] and entropic regularization [Peyré et al., 2016, Gold and Rangarajan, 1996].
+
+Related works and contributions. The concomitant work of De Ponti and Mondino [2020] extends the $L ^ { p }$ transportation distance defined in Sturm et al. [2006] to unbalanced mm-spaces and studies its geometric properties. This distortion distance is not equivalent to the GW distance, and is more difficult to estimate numerically because it explicitly imposes a triangle inequality constraint in the optimization problem. The work of Chapel et al. [2020] relaxes the GW distance to the unbalanced setting by hybridizing GW with partial OT [Figalli, 2010] for unsupervised labeling. It ressembles one particular setting of our formulation, but with some important differences, detailed in Section 2. Our construction is also connected to partial matching methods, which find numerous applications in graphics and vision [Cosmo et al., 2016]. In particular, Rodola et al. [2012] introduces a mass conservation relaxation of the GW problem.
+
+The two main contributions of this paper are the definition of two formulations relaxing the GW distance. The first one is called the Unbalanced Gromov-Wasserstein (UGW) divergence and can be computed efficiently on GPUs. The second one is called the Conic Gromov-Wasserstein distance (CGW). It is proved to be a distance between mm-spaces endowed with positive measures up to isometries, as stated in Theorem 1 which is the main theoretical result of this paper. We also prove in Theorem 1 that UGW can be used as a surrogate upper-bounding CGW. We present those concepts and their properties in Section 2. We also detail in Section 3 an efficient computational scheme for a particular setting of UGW. This method computes an approximate stationary point of a biconvex relaxation of our formulations. Even though it is a lower bound of the original problem, we provide in Theorem 3 conditions ensuring the tightness of this relaxation in many cases of interest. The algorithm leverages the strength of entropic regularization and the Sinkhorn algorithm, namely that it is GPU-friendly and defines smooth loss functions amenable to back-propagation for ML applications. Section 4 provides some numerical experiments to highlight the qualitative behavior of this algorithm and its ability to cope with outliers and mass variations in the modes of the distributions. We illustrate numerically the tightness of the relation between UGW and CGW, showing that UGW is a reasonnable proxy of a distance, at least locally. We provide an application of our divergence in the positive unlabeled learning setting, using domain adaptation data, and display results which are at par or outperform the computable competitor Chapel et al. [2020].
+
+# 2 Unbalanced Gromov-Wasserstein formulations
+
+We present in this section our two new formulations and their properties. The first one, called UGW, is exploited in Sections 3 and 4 to derive an efficient algorithm used in numerical experiments. The second one, called CGW, defines a distance between mm-spaces up to isometries. Those results build upon the work of Liero et al. [2015], and a summary of the construction of UOT is detailed in Appendix A. In all what follows, we consider complete separable mm-spaces endowed with a metric and a positive measure.
+
+# 2.1 The unbalanced Gromov-Wasserstein divergence
+
+This new formulation makes use of quadratic $\varphi$ -divergences, defined as $ { \mathbf { D } } _ { \varphi } ^ { \otimes } ( \rho |  { \boldsymbol { \nu } } ) \triangleq  { \mathbf { D } } _ { \varphi } ( \rho \otimes \rho |  { \boldsymbol { \nu } } \otimes  { \boldsymbol { \nu } } )$ , where $\rho \otimes \rho \in \mathcal { M } _ { + } ( X ^ { 2 } )$ is the tensor product measure defined by $\mathrm { d } ( \rho \otimes \rho ) ( x , y ) = \mathrm { d } \rho ( x ) \mathrm { d } \rho ( y )$ . Note that $\mathrm { D } _ { \varphi } ^ { \otimes }$ is not a convex function in general.
+
+Definition 1 (Unbalanced GW). The Unbalanced Gromov-Wasserstein divergence is defined as $\begin{array} { r } { \mathrm { U G W } ( \mathcal { X } , \mathcal { Y } ) = \operatorname* { i n f } _ { \pi \in \mathcal { M } ^ { + } ( X \times Y ) } \mathcal { L } ( \pi ) \triangleq \mathcal { G } ( \pi ) +  { \mathbf { D } } _ { \varphi } ^ { \otimes } ( \pi _ { 1 } | \mu ) +  { \mathbf { D } } _ { \varphi } ^ { \otimes } ( \pi _ { 2 } | \nu ) . } \end{array}$ .
+
+This definition can be understood as an hybridation between (1) and (2) but with a twist: one needs to use the quadratic divergence $\mathrm { D } _ { \varphi _ { \bullet } } ^ { \otimes }$ in place of $\mathrm { D } _ { \varphi }$ . To the best of our knowledge, it is the first time such quadratic divergences are being used and studied. In the TV case, this is the most important distinction between UGW and partial-GW [Chapel et al., 2020]. Note also that the balanced GW distance (2) is recovered as a particular case when using $\varphi = \iota _ { \{ 1 \} }$ or by letting $\rho  + \infty$ for an entropy $\psi = \rho \varphi$ .
+
+Using quadratic divergences results in UGW being 2-homogeneous: for $\theta \geq 0$ , writing $( \mathscr { X } _ { \theta } , \mathscr { y } _ { \theta } )$ equiped with $( \theta \mu , \theta \nu )$ , one has $\theta ^ { - 2 } \mathrm { U G W } ( \mathcal { X } _ { \theta } , \mathcal { Y } _ { \theta } ) \bar { \ } = \mathrm { U G W } ( \mathcal { X } , \mathcal { Y } )$ . When using non tensorized $\varphi$ -divergences, the resulting unbalanced Gromov-Wassertein functional between $\mathcal { X } _ { \theta }$ and $\mathcal { { D } } _ { \theta }$ have very different and inconsistent behaviors when $\theta  0$ and $\theta \to + \infty$ . Indeed, once normalized by $\theta ^ { - \bar { 2 } }$ and $\theta ^ { - 1 }$ , one obtains respectively balanced GW and a Hellinger-type distance. Using tensorized divergences ensures that the behavior does not depends on $\theta$ . It is also fundamental to connect UGW with our distance CGW, see Theorem 1 and Appendix B.
+
+We first prove the existence of optimal plans $\pi$ minimizing $\mathcal { L }$ , which holds for the three key settings of Section 2.2.1, namely for KL, TV, and for compact metric spaces (such as finite pointclouds and graphs). All proofs are deferred in Appendix B.
+
+Proposition 1 (Existence of minimizers). We assume that $( X , Y )$ are compact and that either $( i ) \varphi$ superlinear, i.e $\varphi _ { \infty } ^ { \prime } = \infty$ , or (ii) $\lambda$ has compact sublevel sets in $\mathbb { R } _ { + }$ and $2 \varphi _ { \infty } ^ { \prime } + \operatorname* { i n f } \lambda > 0$ . Then there exists $\pi \in { \mathcal { M } } _ { + } ( X \times Y )$ such that $\mathrm { U G } \mathrm { \bar { w } } ( \mathcal { X } , \mathcal { Y } ) = \mathcal { L } ( \pi )$ .
+
+The following proposition ensures that the functional UGW can be used to compare mm-spaces.
+
+Proposition 2 (Definiteness of UGW). Assume that $\varphi ^ { - 1 } ( \{ 0 \} ) = \{ 1 \}$ and $\lambda ^ { - 1 } ( \{ 0 \} ) = \{ 0 \}$ . Then $\mathrm { U G W } ( \mathcal { X } , \mathcal { Y } ) \ge 0$ and is 0 if and only if $\mathcal { X } \sim \mathcal { V }$ .
+
+We end this section with a reformulation of UGW which is important to make the connection with the second formulation CGW of the following section. It splits UGW into two parts: the term $\varphi ( 0 ) ( | ( \mu \otimes \mu ) ^ { \perp } | + | ( \nu \otimes \nu ) ^ { \perp } | )$ accounts for the pure creation/destruction of mass and a new transport cost $L _ { c }$ accounts for the remaining part (partial/pure transport and partial creation/destruction of mass).
+
+Lemma 1. Defining $L _ { c } ( a , b ) \triangleq c + a \varphi ( 1 / a ) + b \varphi ( 1 / b ) \operatorname { \mathrm { , } }$ , and writing $\begin{array} { r } { ( f \triangleq \frac { \mathrm { d } \mu } { \mathrm { d } \pi _ { 1 } } , g \triangleq \frac { \mathrm { d } \nu } { \mathrm { d } \pi _ { 2 } } ) } \end{array}$ the Lebesgue densities of $( \mu , \nu )$ w.r.t. $( \pi _ { 1 } , \pi _ { 2 } )$ such that $\mu = f \pi _ { 1 } + \mu ^ { \perp }$ and $\nu = g \pi _ { 2 } + \nu ^ { \perp }$ , one has
+
+$$
+\mathcal { L } ( \pi ) = \int _ { X ^ { 2 } \times Y ^ { 2 } } L _ { \lambda ( | d _ { X } - d _ { Y } | ) } ( f \otimes f , g \otimes g ) \mathrm { d } \pi \mathrm { d } \pi + \varphi ( 0 ) ( | ( \mu \otimes \mu ) ^ { \perp } | + | ( \nu \otimes \nu ) ^ { \perp } | ) .
+$$
+
+Proof. Write $\begin{array} { r } { f = \frac { \mathrm { d } \mu } { \mathrm { d } \pi _ { 1 } } } \end{array}$ and $\begin{array} { r } { g = \frac { \mathrm { d } \nu } { \mathrm { d } \pi _ { 2 } } } \end{array}$ The Lebesgue decompositions read $\mu \otimes \mu = ( f \otimes f ) \pi _ { 1 } \otimes$ $\pi _ { 1 } + ( \mu \otimes \mu ) ^ { \perp }$ and $\nu \otimes \nu = ( g \otimes g ) \pi _ { 2 } \otimes \pi _ { 2 } + ( \nu \otimes \nu ) ^ { \perp }$ , thanks to the tensorized structure of the decomposed plans. To prove Equation (3), we need to define the reverse entropy Liero et al. [2015] such that $\mathrm { D } _ { \varphi } ( \alpha | \mu ) = \mathrm { D } _ { \psi } ( \mu | \alpha )$ , where $\psi ( x ) \triangleq x \varphi ( { \frac { 1 } { x } } )$ is also an entropy function satisfying $\psi _ { \infty } ^ { \prime } = \varphi ( 0 )$ . One then has
+
+$$
+\begin{array} { r } { \mathcal { L } ( \pi ) = \displaystyle \int _ { X ^ { 2 } \times Y ^ { 2 } } \lambda ( \Gamma ) \mathrm { d } \pi \mathrm { d } \pi + \mathbf { D } _ { \varphi } ^ { \otimes } ( \pi _ { 1 } | \mu ) + \mathbf { D } _ { \varphi } ^ { \otimes } ( \pi _ { 2 } | \nu ) } \\ { = \displaystyle \int _ { X ^ { 2 } \times Y ^ { 2 } } \lambda ( \Gamma ) \mathrm { d } \pi \mathrm { d } \pi + \mathbf { D } _ { \psi } ^ { \otimes } ( \mu | \pi _ { 1 } ) + \mathbf { D } _ { \psi } ^ { \otimes } ( \nu | \pi _ { 2 } ) } \end{array}
+$$
+
+$$
+\begin{array} { l } { \displaystyle \mathcal { L } ( \pi ) = \int _ { X ^ { 2 } \times Y ^ { 2 } } \lambda ( \Gamma ) \mathrm { d } \pi \mathrm { d } \pi + \int _ { X ^ { 2 } } \psi ( f \otimes f ) \mathrm { d } \pi _ { 1 } \mathrm { d } \pi _ { 1 } + \int _ { Y ^ { 2 } } \psi ( g \otimes g ) \mathrm { d } \pi _ { 2 } \mathrm { d } \pi _ { 2 } } \\ { \displaystyle \qquad + \varphi ( 0 ) ( | ( \mu \otimes \mu ) ^ { \perp } | + | ( \nu \otimes \nu ) ^ { \perp } | ) } \\ { \displaystyle = \int _ { X ^ { 2 } \times Y ^ { 2 } } L _ { \lambda ( \Gamma ) } ( f \otimes f , g \otimes g ) \mathrm { d } \pi \mathrm { d } \pi + \varphi ( 0 ) ( | ( \mu \otimes \mu ) ^ { \perp } | + | ( \nu \otimes \nu ) ^ { \perp } | ) . } \end{array}
+$$
+
+Using the definition of $\psi$ in $L _ { c }$ ends the proof.
+
+# 2.2 The conic Gromov-Wasserstein distance
+
+We introduce a second “conic” formulation of unbalanced GW, which is connected to UGW, and whose construction is inspired by the conic formulation of UOT (see Appendix A for an overview).
+
+# 2.2.1 Background on cone sets and distances
+
+The conic formulation lifts a point $x \in X$ to a couple $( x , r ) \in X \times \mathbb { R } ^ { + }$ where $r$ encodes some (power of a) mass. Then we seek optimal transport plans defined over ${ \mathfrak { C } } [ X ] \triangleq X \times \mathbb { R } _ { + } / ( X \times \{ 0 \} )$ , where coordinates $( x , r = 0 )$ ) with no mass are merged into a single point $\circ _ { X }$ called the apex of the cone. In the sequel, points of $X \times \mathbb { R } _ { + }$ are noted $( x , r )$ , while $[ x , r ]$ are quotiented points of ${ \mathfrak { C } } [ X ]$ .
+
+While transport plans depend on variables $\left( [ x , r ] , [ y , s ] \right)$ and $( [ x ^ { \prime } , r ^ { \prime } ] , [ y ^ { \prime } , s ^ { \prime } ] )$ in ${ \mathfrak { C } } [ X ] \times { \mathfrak { C } } [ Y ]$ , the transportation cost involved in our conic formulation only makes use of the 2-D cone ${ \mathfrak { C } } [ \mathbb { R } _ { + } ]$ over $\mathbb { R } _ { + }$ endowed with the distance $\left| u - v \right|$ (note that any other distance on $\mathbb { R }$ could be used as well). More specifically, we consider coordinates of the form $( [ u , a ] , [ v , b ] ) = ( [ d _ { X } ( x , x ^ { \prime } ) , r r ^ { \prime } ] , [ d _ { Y } ( y , y ^ { \prime } ) , s s ^ { \bar { \prime } } ] ) \in$ ${ \mathfrak { C } } [ \mathbb { R } _ { + } ] \times { \mathfrak { C } } [ \mathbb { R } _ { + } ]$ . Thus we now describe conic discrepancies $\mathcal { D }$ on ${ \mathfrak { C } } [ \mathbb { R } _ { + } ]$ , which are defined for $( p , q ) \geq 1$ as ${ \mathcal { D } } ( [ u , a ] , [ v , b ] ) ^ { q } \triangleq H _ { \lambda ( \vert u - v \vert ) } ( a ^ { p } , b ^ { p } )$ , where $\begin{array} { r } { H _ { c } ( a ^ { p } , b ^ { p } ) \triangleq \operatorname* { i n f } _ { \theta \geq 0 } \theta L _ { c } ( \frac { a ^ { p } } { \theta } , \frac { b ^ { p } } { \theta } ) } \end{array}$ is the perspective transform of $L _ { c }$ introduced in Lemma 1. The intuition underpinning the definition of this cost is that the perspective transform accounts for the possibility to rescale a transport plan $\pi$ by a scalar $\theta$ but the scaling is performed pointwise instead of globally. In general $\mathcal { D }$ is not a distance, but it is always definite as stated by this result proved in Appendix A.
+
+Proposition 3. Assume $\lambda ^ { - 1 } ( \{ 0 \} ) = \{ 0 \}$ , $\varphi ^ { - 1 } ( \{ 0 \} ) = \{ 1 \}$ and $\varphi$ is coercive. Then $\mathcal { D }$ is definite on $\mathfrak { C } [ \mathbb { R } ^ { + } ] \mathrm { . }$ , i.e. $\mathcal { D } ( [ u , a ] , [ v , b ] ) = \mathrm { \dot { 0 } }$ if and only if $\overset { \prime } { a } = b = 0$ ) or ${ a = b }$ and $u = v$ ).
+
+Of particular interest are those $\varphi$ where $\mathcal { D }$ is a distance, which necessitates a careful choice of $\lambda , p$ and $q$ . We now detail three examples where this is the case.
+
+Gaussian Hellinger distance (GH). When $\mathrm { D } _ { \varphi } = \mathrm { K L }$ , $\lambda ( t ) = t ^ { 2 }$ and $q = p = 2$ , then one has $\mathcal { D } ( [ u , a ] , [ v , b ] ) ^ { 2 } = a ^ { 2 } + b ^ { 2 } - 2 a b e ^ { - | u - v | / 2 }$ . This cone distance [Burago et al., 2001] is further generalized by De Ponti [2019] who shows that $\mathcal { D }$ is a distance for power entropies $\begin{array} { r } { \varphi ( s ) = \frac { s ^ { p } - p ( s - 1 ) - 1 } { p ( p - 1 ) } } \end{array}$ if $p \geq 1$ (the case $p = 1$ corresponding to $\mathrm { D } _ { \varphi } = \mathrm { K L }$ ).
+
+Hellinger-Kantorovich (HK) $/$ Wasserstein-Fisher-Rao distance (WFR). When $\mathrm { D } _ { \varphi } ~ = ~ \mathrm { K L }$ , $\begin{array} { r } { \lambda ( t ) = - \log \cos ^ { 2 } ( t \wedge \frac { \pi } { 2 } ) } \end{array}$ and $q = p = 2$ , then one has $\begin{array} { r } { \mathcal { D } ( [ u , a ] , [ v , b ] ) ^ { 2 } = a ^ { 2 } + b ^ { 2 } - 2 a b \cos ( \frac { \pi } { 2 } \wedge | u - } \end{array}$ $v | ,$ . This construction, which might seem peculiar, corresponds to the one used to make unbalanced OT a geodesic distance, as detailed in [Liero et al., 2015, Chizat et al., 2018a].
+
+Partial optimal transport distance (PT). When $\mathbf { D } _ { \varphi } = \mathrm { T V }$ , $\lambda ( t ) = t ^ { q }$ , $q \geq 1$ and $p = 1$ , then ${ \mathcal { D } } ( [ u , a ] , { \bar { [ } } v , b ] ) ^ { q } = a + { \bar { b } } - ( a \wedge b ) ( 2 - | u - v | ^ { q } ) _ { + }$ defines a cone distance [Chizat et al., 2018a].
+
+# 2.2.2 Definitions and properties
+
+The conic formulation consists in solving a GW problem on the cone, with the addition of two linear constraints. Informally speaking, $L _ { c }$ from Lemma 1 becomes $\mathcal { D }$ , the term $( | ( \mu \otimes \mu ) ^ { \perp } | + | ( \nu \otimes \nu ) ^ { \perp } | )$ is taken into account by the constraints (5) below, and the variables $( f , g )$ are replaced by $( r ^ { p } , s ^ { p } )$ . It reads $\begin{array} { r } { \mathrm { C G W } ( \mathcal { X } , \mathcal { Y } ) \triangleq \operatorname* { i n f } _ { \alpha \in \mathcal { U } _ { p } ( \mu , \nu ) } \mathcal { H } ( \alpha ) } \end{array}$ where
+
+$$
+\mathcal { H } ( \alpha ) \triangleq \int \mathcal { D } ( [ d _ { X } ( x , x ^ { \prime } ) , r r ^ { \prime } ] , [ d _ { Y } ( y , y ^ { \prime } ) , s s ^ { \prime } ] ) ^ { q } \mathrm { d } \alpha ( [ x , r ] , [ y , s ] ) \mathrm { d } \alpha ( [ x ^ { \prime } , r ^ { \prime } ] , [ y ^ { \prime } , s ^ { \prime } ] ) ,
+$$
+
+and $\mathcal { U } _ { p } ( \mu , \nu )$ is defined as the set
+
+$$
+\mathcal { U } _ { p } ( \mu , \nu ) \triangleq \left\{ \alpha \in \mathcal { M } _ { + } ( \mathfrak { C } [ X ] \times \mathfrak { C } [ Y ] ) , \ \int _ { \mathbb { R } _ { + } } r ^ { p } \mathrm { d } \alpha _ { 1 } ( \cdot , r ) = \mu , \ \int _ { \mathbb { R } _ { + } } s ^ { p } \mathrm { d } \alpha _ { 2 } ( \cdot , s ) = \nu \right\} .
+$$
+
+It is similar to the conic formulation of UW, see Appendix A. Note that similarly to the GW formulation (2) – and in sharp contrast with the conic formulation of UW – here the transport plans are defined on the cone ${ \mathfrak { C } } [ X ] ^ { - } \times { \mathfrak { C } } [ Y ]$ but the cost $\mathcal { D }$ is a distance on ${ \mathfrak { C } } [ \mathbb { R } _ { + } ]$ .
+
+We present now the main contributions of this paper, proved in Appendix C. We state that CGW defines a distance under conditions that hold for the settings of Section 2.2.1, and that it is upperbounded by UGW. The divergence UGW can be approximated with efficient numerical schemes as detailed in Section 3.
+
+Theorem 1. (i) The divergence CGW is symmetric, positive and definite up to isometries. (ii) If $\mathcal { D }$ is a distance on ${ \mathfrak { C } } [ \mathbb { R } _ { + } ]$ , then $\mathrm { C G W ^ { 1 / \boldsymbol { q } } }$ is a distance on the set of mm-spaces up to isometries. (iii) For any $( \mathbf { D } _ { \varphi } , \lambda , p , q )$ with associated cost $\mathcal { D }$ on the cone, one has $\mathrm { U G W } \geq \mathrm { C G W }$ .
+
+# 3 Algorithms
+
+We focus in this section on the numerical computation of the upper bound UGW using a bi-convex relaxation and derive an alternate minimization scheme coupled with entropic regularization. We also propose to approximate CGW by doing a similar alternate minimization, as detailed in Appendix E. We provide guarantees of tightness on the bi-convex relaxation for CGW (see Theorem 3). The computation of the distance CGW is heavy in practice because it requires an optimization over a lifted conic space, which needs to be discretized. Thus it does not scale to large problem for CGW, but allows to explore numerically how tight is the upper bound $\mathrm { U G W } \geq \mathrm { C G W }$ , see Section 4. The algorithm for UGW is presented on arbitrary measures, the special case of discrete measures being a particular case. The discretized formulas and algorithms are detailed in Appendix D, see also Chizat et al. [2018b], Peyré et al. [2016]. All implementations are available at https: //github.com/thibsej/unbalanced_gromov_wasserstein, and installable in Python with the command pip install unbalancedgw.
+
+# 3.1 Bi-convex relaxation and tightness
+
+In order to derive a simple numerical approximation scheme, following Mémoli [2011], we introduce a lower bound obtained by introducing two transportation plans. To further accelerate the method and enable GPU-friendly iterations, similarly to Gold et al. [1996], Solomon et al. [2016], we consider an entropic regularization. It reads, for any $\varepsilon \geq 0$ ,
+
+$$
+\begin{array} { r l r } { \mathrm { U G W } _ { \varepsilon } ( X , y ) \triangleq \underset { \pi } { \operatorname { i n f } } \mathscr { L } ( \pi ) + \varepsilon \mathrm { K L } ^ { \otimes } ( \pi | \mu \otimes \nu ) \geq \underset { \pi , \gamma } { \operatorname { i n f } } \mathscr { F } ( \pi , \gamma ) + \varepsilon \mathrm { K L } ( \pi \otimes \gamma | ( \mu \otimes \nu ) ^ { \otimes 2 } ) , } & { } & { ( 6 ) } \\ { \mathrm { a n d } } & { \mathscr { F } ( \pi , \gamma ) \triangleq \displaystyle \int _ { X ^ { 2 } \times Y ^ { 2 } } \lambda ( | d _ { X } - d _ { Y } | ) \mathrm { d } \pi \otimes \gamma + \mathrm { D } _ { \varphi } ( \pi _ { 1 } \otimes \gamma _ { 1 } | \mu \otimes \mu ) + \mathrm { D } _ { \varphi } ( \pi _ { 2 } \otimes \gamma _ { 2 } | \nu \otimes \nu ) , } & { } & \end{array}
+$$
+
+where $( \gamma _ { 1 } , \gamma _ { 2 } )$ denote the marginals of the plan $\gamma$ . In the sequel we write $\mathcal { F } _ { \varepsilon } = \mathcal { F } + \varepsilon \mathrm { K L } ^ { \otimes }$ . Note that in contrast to the entropic regularization of GW Peyré et al. [2016], here we use a tensorized entropy to maintain the overall homogeneity of the energy. A simple method to approximate this lower bound is to perform an alternate minimization on $\pi$ and $\gamma$ , which is known to converge for smooth $\varphi$ to a stationary point since the coupling term in the functional is smooth [Tseng, 2001]. Note that if $\pi \otimes \gamma$ is optimal then so is $\left( s \pi \right) \bar { \otimes } \left( { \textstyle { \frac { 1 } { s } } } \bar { \gamma } \right)$ with $s \geq 0$ . Thus without loss of generality we can optimize under the constraint $m ( \pi ) = m ( \gamma )$ by setting $s = \sqrt { m ( \gamma ) / m ( \pi ) }$ .
+
+We now discuss the tightness of the bi-convex relaxation by generalizing a result of Konno. We first present a result which applies to general quadratic assignment problems, then state its application to our setting.
+
+Theorem 2 (Tight relaxation). Let $B$ a Banach space, let $f : B \mapsto \mathbb { R } \cup \{ + \infty \}$ be a function and let $\mathcal { L } : C \subset B \mapsto \mathbb { R }$ the function defined on the convex set $C \subset B$ by $\begin{array} { r } { \mathcal { L } ( { \boldsymbol \pi } ) = \frac { 1 } { 2 } \langle { \boldsymbol \pi } , k ( { \boldsymbol \pi } ) \rangle + 2 f ( { \boldsymbol \pi } ) } \end{array}$ where $k$ is a symmetric bilinear map which is negative (not necessarily definite) on $\Delta C \triangleq { \mathrm { S p a n } } ( \{ \pi -$ $\gamma ; ( \pi , \overset { \cdot } { \gamma } ) \in C \}$ ), that is, for any $z \in \Delta C$ , $\langle z , k z \rangle \leq 0$ . Assume that there exists $\pi _ { 0 } \in C$ such that $\mathcal { L } ( \pi _ { 0 } ) < + \infty$ , and define $\mathcal { F } ( \pi , \gamma ) \triangleq \frac { _ 1 } { ^ 2 } \langle \pi , k ( \gamma ) \rangle + f ( \pi ) + f ( \gamma )$ . Then, for any $( \pi _ { * } , \gamma _ { * } ) \in$ arg min $\mathcal { F } ( \pi , \gamma )$ , we have $\mathcal { F } ( \pi _ { * } , \pi _ { * } ) = \mathcal { F } ( \bar { \gamma _ { * } } , \gamma _ { * } ) = \mathcal { F } ( \pi _ { * } , \gamma _ { * } )$ . Moreover, if one assumes either that $k$ is a definite kernel or $f$ is strictly convex, one gets $\pi _ { * } = \gamma _ { * }$ .
+
+The above Theorem 2 is proved in Appendix D. As an application, we now state our tightness result for $\mathrm { G W } _ { \varepsilon }$ and CGW. In those settings the optimizers of the bi-convex relaxation are also optimal for the original problem.
+
+Theorem 3. For $G W _ { \varepsilon }$ with $\varepsilon \geq 0$ or for CGW, assume that $\lambda ( t ) = t ^ { 2 }$ and that $( d _ { X } , d _ { Y } )$ are both conditionnally negative (or conditionally positive) kernels. Then the bi-convex relaxation of both problems is tight.
+
+Proof. The proof for CGW is detailed in Appendix E, we prove the tightness for $\mathrm { G W } _ { \varepsilon }$ . When $\lambda ( t ) =$ $t ^ { 2 }$ the kernel $k = \lambda ( | d _ { X } - d _ { Y } | )$ is conditionally negative on the set $\{ ( \pi , \gamma ) , \ \pi _ { 1 } = \gamma _ { 1 }$ and $\pi _ { 2 } = \gamma _ { 2 } \}$ , i.e. we have $\langle ( \pi - \gamma ) \rangle$ , $k ( \pi - \gamma ) \rangle \leq 0$ (see Maron and Lipman [2018]). For $\mathrm { G W } _ { \varepsilon }$ one has $\pi _ { 1 } = \gamma _ { 1 } = \mu$ and $\pi _ { 2 } = \gamma _ { 2 } = \nu$ thanks to the constraints on marginals. Thus the kernel is negative semi-definite and the proof of Theorem 2 applies, hence the tightness of the relaxation. □
+
+Konno’s result Konno [1976] applies for unregularized $\mathit { \Omega } ( \varepsilon = 0 ) ,$ ), Balanced-GW. The novelty of Theorem 3 is its extension to both $\mathrm { G W } _ { \varepsilon }$ and CGW. So far it is an open question whether the relaxation is tight or not for $\mathrm { U G W } _ { \varepsilon }$ , because the above proof no longer holds. Note that in all our numerical simulations, our solvers always found solutions of $\mathrm { U G W } _ { \varepsilon }$ such that $\pi = \gamma$ when $| d _ { X } - d _ { Y } | ^ { 2 }$ is conditonally negative. The property that the kernel $| d _ { X } - d _ { Y } | ^ { 2 }$ is negative does not hold in general (e.g. for graph geodesic distances) and the tightness of the relaxation remains open in this setting. We know from [Maron and Lipman, 2018, Theorem 1] that it is conditionally negative semi-definite when both $( d _ { X } , d _ { Y } )$ are conditionally negative kernels. Examples of distances which are negative kernels are tree metrics in the case of graphs, as well as Euclidean, spherical and hyperbolic distances over their respective manifolds Feragen et al. [2015]. In practice, when $\varepsilon$ is small, we observed in the indefinite setting that the relaxation outputs more frequently spurious minima than in the negative semi-definite setting.
+
+# 3.2 Alternate Sinkhorn minimization
+
+Minimizing the lower bound (6) with respect to either $\pi$ or $\gamma$ is non-trivial for an arbitrary $\varphi$ . We restrict our attention to the Kullback-Leibler case $\mathrm { D } _ { \varphi } = \rho \mathrm { K L }$ with $\rho > 0$ , which can be addressed by solving a regularized and convex unbalanced problem as studied in Chizat et al. [2018b], Séjourné et al. [2019]. It is explained in the following proposition.
+
+Proposition 4. For a fixed $\gamma _ { i }$ , the optimal $\pi \in \arg \operatorname* { m i n } _ { \pi } \mathcal { F } ( \pi , \gamma ) + \varepsilon \mathrm { K L } ( \pi \otimes \gamma | ( \mu \otimes \nu ) ^ { \otimes 2 } )$ solves
+
+$$
+\operatorname* { m i n } _ { \pi } \int c _ { \gamma } ^ { \varepsilon } ( x , y ) \mathrm { d } \pi ( x , y ) + \rho m ( \gamma ) \mathrm { K L } ( \pi _ { 1 } | \mu ) + \rho m ( \gamma ) \mathrm { K L } ( \pi _ { 2 } | \nu ) + \varepsilon m ( \gamma ) \mathrm { K L } ( \pi | \mu \otimes \nu ) ,
+$$
+
+where $m ( \gamma ) \triangleq \gamma ( X \times Y )$ is the mass of $\gamma _ { i }$ , and where we define the cost associated to $\gamma$ as
+
+$$
+\varepsilon _ { \gamma } ^ { \varepsilon } ( x , y ) \triangleq \int \lambda ( | d x ( x , \cdot ) - d _ { Y } ( y , \cdot ) | ) \mathrm { d } \gamma + \rho \int \log ( \frac { \mathrm { d } \gamma _ { 1 } } { \mathrm { d } \mu } ) \mathrm { d } \gamma _ { 1 } + \rho \int \log ( \frac { \mathrm { d } \gamma _ { 2 } } { \mathrm { d } \nu } ) \mathrm { d } \gamma _ { 2 } + \varepsilon \int \log ( \frac { \mathrm { d } \gamma } { \mathrm { d } \mu \mathrm { d } \nu } ) \mathrm { d } \gamma .
+$$
+
+Computing the cost $c _ { \gamma } ^ { \varepsilon }$ for spaces $X$ and $Y$ of $n$ points has in general a cost ${ \dot { O } } ( n ^ { 4 } )$ in time and memory. However, as explained for instance in Peyré et al. [2016], for the special case $\lambda ( t ) = t ^ { 2 }$ , this cost is reduced to $O ( n ^ { 3 } )$ in time and ${ \dot { O } } ( n ^ { 2 } )$ in memory. This is the setting we consider in the numerical simulations. This makes the method applicable for scales of the order of $1 0 ^ { 4 }$ points. For larger datasets one should use approximation schemes such as hierarchical approaches [Xu et al., 2019] or Nyström compression of the kernel [Altschuler et al., 2018].
+
+The resulting alternate minimization method is detailed in Algorithm 1, see Appendix D for a discretized version. It uses the unbalanced Sinkhorn algorithm of Chizat et al. [2018b], Séjourné et al. [2019] as subiterations and takes $\pi = \mu \otimes \nu / \sqrt { m ( \mu ) m ( \nu ) }$ to ini
+
+$$
+\overline { { \mathbf { A l g o r i t h m 1 - U G W } ( \mathcal { X } , \mathcal { V } , \rho , \varepsilon ) } }
+$$
+
+Input: mm-spaces $( \mathcal { X } , \mathcal { Y } )$ , relax. $\rho$ , regul. $\varepsilon$   
+Output: $\pi , \gamma$ solving (6) Init. $\pi = \gamma = \mu \otimes \nu / { \sqrt { m ( \mu ) m ( \nu ) } } , g =$ $g = 0$ . while $( \pi , \gamma )$ has not converged do Update $\pi  \gamma$ , then $c \gets c _ { \pi } ^ { \varepsilon } , \tilde { \rho } \gets m ( \pi ) \rho , \tilde { \varepsilon } \gets m ( \pi ) \varepsilon$ while $( f , g )$ has not converged do $\begin{array} { r } { f \gets - \frac { \tilde { \varepsilon } \tilde { \rho } } { \tilde { \varepsilon } + \tilde { \rho } } \log { \int e ^ { ( g ( y ) - c ( \cdot , y ) ) / \tilde { \varepsilon } } \mathrm { d } \nu ( y ) } } \end{array}$ $\begin{array} { r } { g \gets - \frac { \tilde { \varepsilon } \tilde { \rho } } { \tilde { \varepsilon } + \tilde { \rho } } \log \int e ^ { ( f ( x ) - c ( x , \cdot ) ) / \tilde { \varepsilon } } \mathrm { d } \mu ( x ) } \end{array}$ end while Upd. $\begin{array} { l } { { \widehat { \gamma ( x , y ) } {  } e ^ { \frac { f ( x ) + g ( y ) - c ( x , y ) } { \widehat { \varepsilon } } } \mu ( x ) \nu ( y ) } } \end{array}$ Rescale $\gamma  \sqrt { m ( \pi ) / m ( \gamma ) } \gamma$ end while Return $( \pi , \gamma )$ .
+
+tialize the updates. This Sinkhorn algorithm operates over a pair of continuous functions (so-called
+
+Kantorovitch potentials) $f ( x )$ and $g ( y )$ . For discrete spaces $X$ and $Y$ of size $n$ , these functions are stored in vectors of size $n$ , and that integral involved in the updates becomes a sum. Each iteration of Sinkhorn thus has a cost $n ^ { 2 }$ , and all the involved operation can be efficiently mapped to parallelizable GPU routines as detailed in Chizat et al. [2018b], Séjourné et al. [2019]. Another advantage of using an unbalanced Sinkhorn algorithm is its complexity $O ( n ^ { 2 } / \varepsilon )$ to compute an $\varepsilon$ -approximation, as stated in Pham et al. [2020], which should be compared to ${ \cal O } ( n ^ { 2 } / \varepsilon ^ { 2 } )$ operations for balanced Sinkhorn.
+
+Note also that balanced GW is recovered as a special case when setting $\rho \to + \infty$ , so that $\tilde { \rho } / ( \tilde { \varepsilon } +$ $\tilde { \rho } )  1$ should be used in the iterations. In order to speed up Sinkhorn inner-loops, especially for small values of $\varepsilon$ , one can use linear extrapolation [Thibault et al., 2017] or non-linear Anderson acceleration [Anderson, 1965, Scieur et al., 2016].
+
+There is an extra scaling step after computing $\gamma$ involving the mass $m ( \pi )$ . It corresponds to the scaling $s$ of $\pi \otimes \gamma$ such that $m ( \pi ) = m ( \gamma )$ , and we observe that this scaling is key not only to impose this mass equality but also to stabilize the algorithm. Otherwise we observed that $m ( \gamma ) < 1 < \bar { m } ( \pi )$ and underflows whenever $m ( \gamma ) \to 0$ and $\bar { m ( \pi ) } \to \infty$ .
+
+# 4 Numerical experiments
+
+This section presents simulations on synthetic examples to highlight the qualitative behavior of UGW and the tightness of the bound $\mathrm { U G W } \geq \mathrm { C G W }$ . Other illustrations on UGW are available in Appendix E. We end the section with a learning application of UGW in a positive-unlabeled setting, using domain adaptation data so as to compare with PGW Chapel et al. [2020]. In the synthetic experiments, $\mu$ and $\nu$ are probability distributions, which allows us to compare GW with UGW.
+
+Robustness to imbalanced classes. In this first example, we take $X = \mathbb { R } ^ { 3 }$ , $Y = \mathbb { R } ^ { 2 }$ and consider $\mathcal { E } _ { 2 } , \mathcal { E } _ { 3 }$ , $\mathcal { C }$ and $s$ to be uniform distributions on a 2D and 3D ellipse, a square and a sphere. We consider mm-spaces of different dimensions to emphasize the ability of (U)GW to compare different spaces. Figure 1 contrasts the transportation plan obtained by GW and UGW for a fixed $\mu = 0 . 5 \mathcal { E } _ { 3 } + 0 . 5 \mathcal { S }$ and $\nu$ obtained using two different mixtures of ${ \mathcal { E } } _ { 2 }$ and $\mathcal { C }$ . The black segments show the largest entries of the transportation matrix $\pi$ , for a sub-sampled set of points (to ease visibility), thus effectively displaying the matching induced by the plan. Furthermore, the width of the dots are scaled according to the mass of the marginals $\pi _ { 1 } \approx \mu$ and $\pi _ { 2 } \approx \nu$ , i.e. the smaller the point, the smaller is the amount of transported mass. This figure shows that the exact conservation of mass imposed by GW leads to a poor geometrical matching of the shapes which have different global mass. As this should be expected, UGW recovers coherent matchings. We suspect the alternate minimization algorithm is able to find the global minimum in these cases.
+
+![](images/f47db5fb8f3450982a0a66e1916d139eb5e73fda2c541eaadd7d5cfe24ea392e.jpg)  
+Figure 1: GW vs. UGW transportation plan, using $\nu = 0 . 3 \mathcal { E } _ { 2 } { + } 0 . 7 \mathcal { C }$ on the left, and $\nu = 0 . 7 \mathcal { E } _ { 2 } \mathrm { + } 0 . 3 \mathcal { C }$ on the right. The 2D mm-spaces is lifted into $\mathbb { R } ^ { 3 }$ by padding the third coordinate to zero.
+
+Tightness of the bound $\mathbf { C G W } { \leq } \mathbf { U G W }$ We propose to approximate CGW by doing a similar alternate minimization as for UGW, as detailed in Appendix E. This numerical scheme does not scale to large problems, but allows us to explore numerically how tight is the upper bound $\mathrm { U G W } \geq \mathrm { C G W }$ Figure 2 highlights the fact that in Euclidean space $\dot { X } = \dot { Y } = \mathbb { R } ^ { d }$ , this bound seems to be tight when the two measures are sufficiently close. We consider discrete measures $\begin{array} { r } { \mu = \frac { 1 } { n } \sum _ { i } \delta _ { x _ { i } } } \end{array}$ in $X = Y = \mathbb { R } ^ { d }$ and $\begin{array} { r } { \nu _ { t } = \frac { 1 } { n } \sum _ { i } \delta _ { y _ { i } } } \end{array}$ where $y _ { i } = x _ { i } + t \Delta _ { i }$ where $\Delta _ { i }$ are random perturbations and denote $( \mathcal { X } , \mathcal { Y } _ { t } )$ the two mm-spaces associated to the Euclidean distance. As $t  0$ , $\mu$ and $\nu _ { t }$ get closer, we observe numerically that $\mathrm { U G W } \approx \mathrm { C G W }$ . Figure 3 considers random points $( x _ { i } ) _ { i }$ and $( y _ { i } ) _ { i }$ and displays the histograms of the ratio CGW/UGW for $n = 3$ . This shows that while the bound $\mathrm { C G W } \leq \mathrm { U G W }$ seems not tight, the ratio appears to be bounded even for points not being close. This numerical experiment suggests that UGW and CGW are locally equivalent and that UGW is in practice an acceptable proxy of the distance CGW. We leave for future works a tighter analysis of the gap between UGW and CGW.
+
+Positive unlabeled learning experiments Positive Unlabeled (PU) learning is a semi-supervised classification problem, where instead of learning from positive and negative samples $( x _ { i } , \ell _ { i } ) _ { i }$ with labels $\ell _ { i } \in \bar { \{ - 1 , 1 \} }$ we only learn from one class labeled with positives, i.e. only those $X \ \triangleq \ \{ x _ { i } : \ell _ { i } = 1 \}$ . The task is to leverage $X$ to predict the classes $\ell = \ell ( y ) \in$ $\{ - 1 , + 1 \}$ of unlabelled $y \in Y$ belong to a separate space. We consider here that $X , Y$ are embedded in Euclidean space, and denote $\mathcal { X } , \mathcal { y }$ the associated labelled and unlabelled mm-spaces, equipped with the uniform distribution. Our experiments are adapted from Partial-GW (PGW) Chapel et al. [2020], which used partial GW to solve PU-learning. The rationale of using unbalanced OT methods for PU learning stems from the fact that positive samples should be matched with positive due to their similar features, while negative samples would be ignored due to dissimilar features that induce a laziness to transport mass and match them.
+
+![](images/e4475ff8de7094efc40c50b639287430c08143782b69fb86b6cbf08cb3d44283.jpg)  
+Figure 2: Comparison of $\operatorname { U G W } ( \mathcal { X } , \mathcal { Y } _ { t } )$ and $\bar { \mathrm { C G W } } ( \mathcal { X } , \mathcal { Y } _ { t } )$ as the support gets shifted by a perturbation.
+
+We consider PU learning over the Caltech office dataset used for domain adaptation tasks (with domains Caltech (C) Griffin et al. [2007], Amazon (A), Webcam (W) and DSLR (D) Saenko et al. [2010]). The Caltech datasets are represented with two embeddings based on Surf and Decaf features Saenko et al. [2010], Donahue et al. [2014]. On the latter datasets, we perform PU learning over similar features (e.g. surf- $C $ surf-\* or decaf-C decaf-\*) and from one feature format to the other (e.g. surf- $C $ decaf-\* or surf- $C $ decaf-\*). Those features are projected via PCA to subspaces of dimension 10 for surf features and 40 for decaf features. In the last task, one cannot use standard PU-method, and to the best of our knowledge, Unbalanced-GW methods are the only approaches for PU learning across different domains/features.
+
+The procedure is the following. We solve the PU learning problem by computing the optimal plan $\pi$ for $\operatorname { U G W } ( \mathcal { X } , \mathcal { Y } )$ We compute its first marginal $\pi _ { 2 }$ on $\mathcal { V }$ , and predict the labels of some $y \in Y$ as $\ell ( y ) \triangleq \operatorname { s i g n } ( \pi _ { 2 } ( y ) - q )$ where $q$ is the quantile of $\pi _ { 2 }$ corresponding to the proportion $r$ of positives samples in $Y$ . Following Chapel et al. [2020] which is adapted from Kato et al. [2018], Hsieh et al. [2019], this proportion $r$ is assumed to be known. We report the accuracy of the prediction over the same 20 folds of the datasets, and use 20 other folds to validate the parameters of UGW. We consider 100 random samples for each fold of $( X , Y )$ , a ratio of positive samples $r = 0 . 1$ for domains (C,A,W,D), and a ratio $r = 0 . 2$ for domains (C,A,W).
+
+![](images/4a0dc32811e8a949315913b7b5c5a46c11a6ea0b91869c0999eefd388abd4f75.jpg)  
+Figure 3: Histograms of the ratio CGW/UGW for random spaces with $n \in \{ 2 , 3 , 5 \}$ samples. Ratios over 1 are due to local minima.
+
+Since the GW objective is non-convex, the initialization of the minimization algorithms is key to obtain good performances. In Chapel et al. [2020] and our experiments, for tasks where $Y$ and $Y$ belong to the same Euclidean space, (e.g. surf- $\mathbf { \partial } \cdot \mathbf { C } \to \operatorname { s u r f } - ^ { * }$ ) we initialize $\pi$ with the Partial-Wasserstein (PW) solution with a squared Euclidean cost. For cross-domain prediction (e.g. surf- $C $ decaf-\*), following Chapel et al. [2020], PGW is initialized with a list of plans built using a coarsened representation of the data with $k$ -NN. While Chapel et al. [2020] makes use in an oracle manner of the plan providing the best accuracy, we modified their protocol and keep the plan which has the lowest PGW cost, which seems fairer, hence the difference in performance with Chapel et al. [2020]. To initialize UGW when $X$ and $Y$ do not belong to the same Euclidean space, we use a UOT solution of a matching between distance histograms called FLB Mémoli [2011]. We define FLB in our UGW setting as
+
+Table 1: Accuracy for all tasks. The left block are domain adaptation experiments with similar features, where both PGW and UGW are initialised with PW. The right block are domain adaptation experiments with different features, and the reported init is FLB (see Appendix E) used for UGW.   
+
+<table><tr><td>Dataset</td><td>prior</td><td>Init (PW)</td><td>PGW</td><td>UGW</td><td>Dataset</td><td>prior</td><td>Init (FLB)</td><td>PGW</td><td>UGW</td></tr><tr><td>surf-C→surf-C</td><td>0.1</td><td>89.9</td><td>84.9</td><td>83.9</td><td>surf-C→decaf-C</td><td>0.1</td><td>85.0</td><td>85.1</td><td>85.6</td></tr><tr><td>surf-C →surf-A</td><td>0.1</td><td>81.8</td><td>82.2</td><td>83.5</td><td>surf-C→decaf-A</td><td>0.1</td><td>84.2</td><td>87.1</td><td>83.6</td></tr><tr><td>surf-C→ surf-W</td><td>0.1</td><td>81.9</td><td>81.3</td><td>80.3</td><td>surf-C→decaf-W</td><td>0.1</td><td>86.2</td><td>88.6</td><td>86.8</td></tr><tr><td>surf-C→surf-D</td><td>0.1</td><td>80.0</td><td>81.4</td><td>83.2</td><td>surf-C →decaf-D</td><td>0.1</td><td>84.7</td><td>91.1</td><td>90.7</td></tr><tr><td>surf-C→surf-C</td><td>0.2</td><td>79.7</td><td>75.7</td><td>75.4</td><td>surf-C→decaf-C</td><td>0.2</td><td>74.8</td><td>75.6</td><td>75.9</td></tr><tr><td>surf-C →surf-A</td><td>0.2</td><td>65.6</td><td>66.0</td><td>76.4</td><td>surf-C →decaf-A</td><td>0.2</td><td>76.2</td><td>87.9</td><td>82.4</td></tr><tr><td>surf-C→surf-W</td><td>0.2</td><td>65.1</td><td>64.3</td><td>67.3</td><td>surf-C→decaf-W</td><td>0.2</td><td>81.5</td><td>88.4</td><td>89.9</td></tr><tr><td>decaf-C→decaf-C</td><td>0.1</td><td>93.9</td><td>83.0</td><td>86.8</td><td>decaf-C→surf-C</td><td>0.1</td><td>81.7</td><td>81.0</td><td>81.1</td></tr><tr><td>decaf-C →decaf-A</td><td>0.1</td><td>80.1</td><td>81.4</td><td>85.6</td><td>decaf-C- →surf-A</td><td>0.1</td><td>80.9</td><td>81.2</td><td>82.4</td></tr><tr><td>decaf-C→decaf-W</td><td>0.1</td><td>80.1</td><td>82.7</td><td>86.1</td><td>decaf-C→ surf-W</td><td>0.1</td><td>82.0</td><td>81.3</td><td>83.5</td></tr><tr><td>decaf-C→decaf-D</td><td>0.1</td><td>80.6</td><td>83.8</td><td>83.4</td><td>decaf-C→surf-D</td><td>0.1</td><td>80.0</td><td>80.8</td><td>81.5</td></tr><tr><td>decaf-C→decaf-C</td><td>0.2</td><td>90.6</td><td>76.7</td><td>80.5</td><td>decaf-C →surf-C</td><td>0.2</td><td>66.6</td><td>63.7</td><td>65.2</td></tr><tr><td>decaf-C→decaf-A</td><td>0.2</td><td>62.5</td><td>68.7</td><td>74.7</td><td>decaf-C- →surf-A</td><td>0.2</td><td>62.9</td><td>62.4</td><td>69.3</td></tr><tr><td>decaf-C → decaf-W</td><td>0.2</td><td>65.7</td><td>75.9</td><td>79.2</td><td>decaf-C→surf-W</td><td>0.2</td><td>65.1</td><td>61.4</td><td>83.3</td></tr></table>
+
+$$
+\mathrm { F L B } ( \mathcal { X } , \mathcal { Y } ) \triangleq \operatorname* { m i n } \int _ { X \times \mathcal { Y } } | \bar { \mu } \star d _ { X } - \bar { \nu } \star d _ { Y } | ^ { 2 } \mathrm { d } \pi + \rho \mathrm { K L } ( \pi _ { 1 } | \mu ) + \rho \mathrm { K L } ( \pi _ { 2 } | \nu ) + \varepsilon \mathrm { K L } ( \pi | \mu \otimes \nu ) ,
+$$
+
+where $\begin{array} { r } { \mu \star d _ { X } ( x ) \triangleq \int d _ { X } ( x , x ^ { \prime } ) \mathrm { d } \mu ( x ^ { \prime } ) } \end{array}$ is the eccentricity, i.e. a histogram of aggregated distances, and $\bar { \mu } = \mu / m ( \mu )$ . Contrary to GW Mémoli [2011], there is a priori no link between FLB and UGW.
+
+In the experiments we slightly generalize UGW and use two different marginal penalties $\rho _ { 1 } \mathrm { K L } ^ { \otimes } ( \pi _ { 1 } ^ { \cdot } | \mu ) + \rho _ { 2 } \mathrm { K L } ^ { \otimes } ( \pi _ { 2 } \overline { { { | } } } \nu )$ with two parameters $( \rho _ { 1 } , \rho _ { 2 } )$ to take into account shifts between domains/features. Note that PGW has a single parameter (which plays a role similar to $\left( \rho _ { 1 } , \rho _ { 2 } \right) )$ which controls the cost of mass creation/destruction. We set $\varepsilon = 2 ^ { - 9 }$ , which avoids introducing an extra parameter in the method. The value $( \rho _ { 1 } , \rho _ { 2 } ) \in \{ 2 ^ { - k }$ , $k \in [ [ 5 , 1 0 ] ] ^ { 2 }$ are cross validated for each J Ktask on the validation folds, and we report the average accuracy on the testing folds. We discuss in Appendix E the impact of reducing the number of parameters on the performance. Comparison with other methods – PU and PUSB Kato et al. [2018], Du Plessis et al. [2014] – are provided in Chapel et al. [2020] and we focus here on the comparison with PGW only.
+
+The results are reported in Table 1. We display the performance of PGW, UGW and the initialization used for UGW to guarantee that using UGW does improve the performance. We observe that when the source and target dataset is the same $\mathrm { C } {  } \mathrm { C }$ tasks), the PW initialization performs better and PGW/UGW degrade the performance, so that in this setting Optimal Transport should be preferred over GW, which is to be expected. However when the domains are different, applying UGW improves the performance over the initialization (which is FLB) in almost all tasks. Note that in that case the methods PU, PUSB or PW cannot be used. Overall, this shows that GW methods are able to solve to some extent the PU learning problem across different spaces, and that using a “softer” KL penalties in UGW is at least at par with Partial GW, and performs better in some settings.
+
+# 5 Conclusion and perspectives
+
+This paper defines two Unbalanced Gromov-Wasserstein formulations: CGW and UGW. We prove that they are both positive and definite. We provide a scalable, GPU-friendly algorithm to compute UGW illustrate its applicability in learning tasks, and show that CGW is a distance between mmspaces up to isometry. These divergences and distances allow for the first time to blend in a seamless way the transportation geometry of GW with creation and destruction of mass. This hybridization is the key to unlock both theoretical and practical issues. This work opens new questions for future works, for instance removing the bias introduced by the use of entropic regularization, which is important for applications to ML. Note that such a debiasing was successfully applied for BalancedGW in Bunne et al. [2019] and is shown to lead to a valid divergence for balanced OT in Feydy et al. [2019b] and UW in Séjourné et al. [2019]. The design of efficient numerical solvers for CGW is also an interesting avenue for future works, as well as the study of its induced topology.
+
+# Acknowledgements
+
+The works of Thibault Séjourné and Gabriel Peyré is supported by the ERC grant NORIA. The work of G. Peyré was supported in part by the French government under management of Agence Nationale de la Recherche as part of the "Investissements d’avenir" program, reference ANR19-P3IA-0001 (PRAIRIE 3IA Institute).
+
+The authors thank Rémi Flamary for his remarks and advices, as well as Laetitia Chapel for her help to reproduce her experiments.
+
+# References
+
+Alexander M Bronstein, Michael M Bronstein, and Ron Kimmel. Generalized multidimensional scaling: a framework for isometry-invariant partial surface matching. Proceedings of the National Academy of Sciences, 103(5):1168–1172, 2006.
+
+Hongteng Xu, Dixin Luo, and Lawrence Carin. Scalable gromov-wasserstein learning for graph partitioning and matching. In Advances in neural information processing systems, pages 3046– 3056, 2019.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pages 1263–1272. JMLR. org, 2017.
+
+Edouard Grave, Armand Joulin, and Quentin Berthet. Unsupervised alignment of embeddings with wasserstein procrustes. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 1880–1890, 2019.
+
+David Alvarez-Melis and Tommi S Jaakkola. Gromov-wasserstein alignment of word embedding spaces. arXiv preprint arXiv:1809.00013, 2018.
+
+Karl-Theodor Sturm. The space of spaces: curvature bounds and gradient flows on the space of metric measure spaces. arXiv preprint arXiv:1208.0434, 2012.
+
+Facundo Mémoli. Gromov–wasserstein distances and the metric approach to object matching. Foundations of computational mathematics, 11(4):417–487, 2011.
+
+Matthias Liero, Alexander Mielke, and Giuseppe Savaré. Optimal entropy-transport problems and a new hellinger–kantorovich distance between positive measures. Inventiones mathematicae, pages 1–149, 2015.
+
+Nicolas Courty, Rémi Flamary, and Devis Tuia. Domain adaptation with regularized optimal transport. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pages 274–289. Springer, 2014.
+
+Charlie Frogner, Chiyuan Zhang, Hossein Mobahi, Mauricio Araya, and Tomaso A Poggio. Learning with a Wasserstein loss. In Advances in Neural Information Processing Systems, pages 2053–2061, 2015.
+
+Martin Arjovsky, Soumith Chintala, and Léon Bottou. Wasserstein GAN. arXiv preprint arXiv:1701.07875, 2017.
+
+Lénaïc Chizat, Gabriel Peyré, Bernhard Schmitzer, and François-Xavier Vialard. Unbalanced optimal transport: Dynamic and kantorovich formulations. Journal of Functional Analysis, 274(11): 3090–3123, 2018a.
+
+Jean Feydy, Pierre Roussillon, Alain Trouvé, and Pietro Gori. Fast and scalable optimal transport for brain tractograms. In International Conference on Medical Image Computing and ComputerAssisted Intervention, pages 636–644. Springer, 2019a.
+
+John Lee, Nicholas P Bertrand, and Christopher J Rozell. Parallel unbalanced optimal transport regularization for large scale imaging problems. arXiv preprint arXiv:1909.00149, 2019.
+
+Yogesh Balaji, Rama Chellappa, and Soheil Feizi. Robust optimal transport with applications in generative modeling and domain adaptation. Advances in Neural Information Processing Systems, 33, 2020.
+
+Lenaic Chizat and Francis Bach. On the global convergence of gradient descent for over-parameterized models using optimal transport. In Advances in neural information processing systems, pages 3036–3046, 2018.
+
+Grant Rotskoff, Samy Jelassi, Joan Bruna, and Eric Vanden-Eijnden. Global convergence of neuron birth-death dynamics. arXiv preprint arXiv:1902.01843, 2019.
+
+Marco Cuturi. Sinkhorn distances: Lightspeed computation of optimal transport. In Adv. in Neural Information Processing Systems, pages 2292–2300, 2013.
+
+Lenaic Chizat, Gabriel Peyré, Bernhard Schmitzer, and François-Xavier Vialard. Scaling algorithms for unbalanced transport problems. to appear in Mathematics of Computation, 2018b.
+
+Thibault Séjourné, Jean Feydy, François-Xavier Vialard, Alain Trouvé, and Gabriel Peyré. Sinkhorn divergences for unbalanced optimal transport. arXiv preprint arXiv:1910.12958, 2019.
+
+Charlotte Bunne, David Alvarez-Melis, Andreas Krause, and Stefanie Jegelka. Learning generative models across incomparable spaces. arXiv preprint arXiv:1905.05461, 2019.
+
+Hongteng Xu, Dixin Luo, Ricardo Henao, Svati Shah, and Lawrence Carin. Learning autoencoders with relational regularization. arXiv preprint arXiv:2002.02913, 2020.
+
+Ivegen Redko, Titouan Vayer, Rémi Flamary, and Nicolas Courty. Co-optimal transport. arXiv preprint arXiv:2002.03731, 2020.
+
+Titouan Vayer, Laetita Chapel, Rémi Flamary, Romain Tavenard, and Nicolas Courty. Fused gromovwasserstein distance for structured objects: theoretical foundations and mathematical properties. arXiv preprint arXiv:1811.02834, 2018.
+
+Samir Chowdhury and Tom Needham. Gromov-wasserstein averaging in a riemannian framework. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition Workshops, pages 842–843, 2020.
+
+David Alvarez-Melis, Stefanie Jegelka, and Tommi S Jaakkola. Towards optimal transport with global invariances. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 1870–1879. PMLR, 2019.
+
+Rainer E Burkard, Eranda Cela, Panos M Pardalos, and Leonidas S Pitsoulis. The quadratic assignment problem. In Handbook of combinatorial optimization, pages 1713–1809. Springer, 1998.
+
+Gabriel Peyré, Marco Cuturi, and Justin Solomon. Gromov-wasserstein averaging of kernel and distance matrices. In International Conference on Machine Learning, pages 2664–2672, 2016.
+
+Steven Gold and Anand Rangarajan. A graduated assignment algorithm for graph matching. IEEE Transactions on pattern analysis and machine intelligence, 18(4):377–388, 1996.
+
+Nicoló De Ponti and Andrea Mondino. Entropy-transport distances between unbalanced metric measure spaces. arXiv preprint arXiv:2009.10636, 2020.
+
+Karl-Theodor Sturm et al. On the geometry of metric measure spaces. Acta mathematica, 196(1): 65–131, 2006.
+
+Laetitia Chapel, Mokhtar Z Alaya, and Gilles Gasso. Partial gromov-wasserstein with applications on positive-unlabeled learning. arXiv preprint arXiv:2002.08276, 2020.
+
+Alessio Figalli. The optimal partial transport problem. Archive for rational mechanics and analysis, 195(2):533–560, 2010.
+
+Luca Cosmo, Emanuele Rodolà, Michael M Bronstein, Andrea Torsello, Daniel Cremers, and Y Sahillioglu. Shrec’16: Partial matching of deformable shapes. Proc. 3DOR, 2(9):12, 2016.
+
+Emanuele Rodola, Alex M Bronstein, Andrea Albarelli, Filippo Bergamasco, and Andrea Torsello. A game-theoretic approach to deformable shape matching. In 2012 IEEE Conference on Computer Vision and Pattern Recognition, pages 182–189. IEEE, 2012.   
+Dmitri Burago, Iu D Burago, Yuri Burago, Sergei A Ivanov, and Sergei Ivanov. A course in metric geometry, volume 33. American Mathematical Soc., 2001.   
+Nicolò De Ponti. Metric properties of homogeneous and spatially inhomogeneous $f$ -divergences. IEEE Transactions on Information Theory, 66(5):2872–2890, 2019.   
+Steven Gold, Anand Rangarajan, et al. Softmax to softassign: Neural network algorithms for combinatorial optimization. Journal of Artificial Neural Networks, 2(4):381–399, 1996.   
+J. Solomon, G. Peyré, V. Kim, and S. Sra. Entropic metric alignment for correspondence problems. ACM Transactions on Graphics (TOG), 35(4), 2016.   
+Paul Tseng. Convergence of a block coordinate descent method for nondifferentiable minimization. Journal of optimization theory and applications, 109(3):475–494, 2001.   
+Haggai Maron and Yaron Lipman. (probably) concave graph matching. arXiv preprint arXiv:1807.09722, 2018.   
+Hiroshi Konno. Maximization of a convex quadratic function under linear constraints. Mathematical programming, 11(1):117–127, 1976.   
+Aasa Feragen, Francois Lauze, and Soren Hauberg. Geodesic exponential kernels: When curvature and linearity conflict. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 3032–3042, 2015.   
+Jason Altschuler, Francis Bach, Alessandro Rudi, and Jonathan Weed. Massively scalable Sinkhorn distances via the nystr\" om method. arXiv preprint arXiv:1812.05189, 2018.   
+Khiem Pham, Khang Le, Nhat Ho, Tung Pham, and Hung Bui. On unbalanced optimal transport: An analysis of sinkhorn algorithm. arXiv preprint arXiv:2002.03293, 2020.   
+Alexis Thibault, Lénaïc Chizat, Charles Dossal, and Nicolas Papadakis. Overrelaxed Sinkhorn-Knopp algorithm for regularized optimal transport. arXiv preprint arXiv:1711.01851, 2017.   
+Donald G Anderson. Iterative procedures for nonlinear integral equations. Journal of the ACM (JACM), 12(4):547–560, 1965.   
+Damien Scieur, Alexandre d’Aspremont, and Francis Bach. Regularized nonlinear acceleration. In Advances In Neural Information Processing Systems, pages 712–720, 2016.   
+Gregory Griffin, Alex Holub, and Pietro Perona. Caltech-256 object category dataset. 2007.   
+Kate Saenko, Brian Kulis, Mario Fritz, and Trevor Darrell. Adapting visual category models to new domains. In European conference on computer vision, pages 213–226. Springer, 2010.   
+Jeff Donahue, Yangqing Jia, Oriol Vinyals, Judy Hoffman, Ning Zhang, Eric Tzeng, and Trevor Darrell. Decaf: A deep convolutional activation feature for generic visual recognition. In International conference on machine learning, pages 647–655. PMLR, 2014.   
+Masahiro Kato, Takeshi Teshima, and Junya Honda. Learning from positive and unlabeled data with a selection bias. In International Conference on Learning Representations, 2018.   
+Yu-Guan Hsieh, Gang Niu, and Masashi Sugiyama. Classification from positive, unlabeled and biased negative data. In International Conference on Machine Learning, pages 2820–2829. PMLR, 2019.   
+Marthinus C Du Plessis, Gang Niu, and Masashi Sugiyama. Analysis of learning from positive and unlabeled data. Advances in neural information processing systems, 27:703–711, 2014.   
+Jean Feydy, Thibault Séjourné, François-Xavier Vialard, Shun-ichi Amari, Alain Trouvé, and Gabriel Peyré. Interpolating between optimal transport and mmd using sinkhorn divergences. In The 22nd International Conference on Artificial Intelligence and Statistics, pages 2681–2690, 2019b.
+
+Matthias Liero, Alexander Mielke, and Giuseppe Savaré. Optimal transport in competition with reaction: The hellinger–kantorovich distance and geodesic curves. SIAM Journal on Mathematical Analysis, 48(4):2869–2911, 2016.
+
+Lenaic Chizat, Gabriel Peyré, Bernhard Schmitzer, and François-Xavier Vialard. An interpolating distance between optimal transport and fisher–rao metrics. Foundations of Computational Mathematics, 18(1):1–44, 2018c.
+
+Cedric Villani. Topics in C. Transportation. Graduate studies in Math. AMS, 2003.
+
+Rémi Flamary and Nicolas Courty. Pot python optimal transport library. GitHub: https://github. com/rflamary/POT, 2017.

parse/train/H1dh6Ax0Z/H1dh6Ax0Z.md

@@ -0,0 +1,375 @@
+# TREEQN AND ATREEC: DIFFERENTIABLE TREE-STRUCTURED MODELS FOR DEEP REINFORCEMENT LEARNING
+
+Gregory Farquhar1 gregory.farquhar@cs.ox.ac.uk
+
+Tim Rocktaschel¨ 1 tim.rocktaschel@cs.ox.ac.uk
+
+Maximilian Igl1 maximilian.igl@cs.ox.ac.uk
+
+Shimon Whiteson1 shimon.whiteson@cs.ox.ac.uk
+
+1University of Oxford, United Kingdom
+
+# ABSTRACT
+
+Combining deep model-free reinforcement learning with on-line planning is a promising approach to building on the successes of deep RL. On-line planning with look-ahead trees has proven successful in environments where transition models are known a priori. However, in complex environments where transition models need to be learned from data, the deficiencies of learned models have limited their utility for planning. To address these challenges, we propose TreeQN, a differentiable, recursive, tree-structured model that serves as a drop-in replacement for any value function network in deep RL with discrete actions. TreeQN dynamically constructs a tree by recursively applying a transition model in a learned abstract state space and then aggregating predicted rewards and state-values using a tree backup to estimate $Q$ -values. We also propose ATreeC, an actor-critic variant that augments TreeQN with a softmax layer to form a stochastic policy network. Both approaches are trained end-to-end, such that the learned model is optimised for its actual use in the tree. We show that TreeQN and ATreeC outperform $n$ -step DQN and A2C on a box-pushing task, as well as $n$ -step DQN and value prediction networks (Oh et al., 2017) on multiple Atari games. Furthermore, we present ablation studies that demonstrate the effect of different auxiliary losses on learning transition models.
+
+# 1 INTRODUCTION
+
+A promising approach to improving model-free deep reinforcement learning (RL) is to combine it with on-line planning. The model-free value function can be viewed as a rough global estimate which is then locally refined on the fly for the current state by the on-line planner. Crucially, this does not require new samples from the environment but only additional computation, which is often available.
+
+One strategy for on-line planning is to use look-ahead tree search (Knuth & Moore, 1975; Browne et al., 2012). Traditionally, such methods have been limited to domains where perfect environment simulators are available, such as board or card games (Coulom, 2006; Sturtevant, 2008). However, in general, models for complex environments with high dimensional observation spaces and complex dynamics must be learned from agent experience. Unfortunately, to date, it has proven difficult to learn models for such domains with sufficient fidelity to realise the benefits of look-ahead planning (Oh et al., 2015; Talvitie, 2017).
+
+A simple approach to learning environment models is to maximise a similarity metric between model predictions and ground truth in the observation space. This approach has been applied with some success in cases where model fidelity is less important, e.g., for improving exploration (Chiappa et al., 2017; Oh et al., 2015). However, this objective causes significant model capacity to be devoted to predicting irrelevant aspects of the environment dynamics, such as noisy backgrounds, at the expense of value-critical features that may occupy only a small part of the observation space (Pathak et al.,
+
+2017). Consequently, current state-of-the-art models still accumulate errors too rapidly to be used for look-ahead planning in complex environments.
+
+Another strategy is to train a model such that, when it is used to predict a value function, the error in those predictions is minimised. Doing so can encourage the model to focus on features of the observations that are relevant for the control task. An example is the predictron (Silver et al., 2017b), where the model is used to aid policy evaluation without addressing control. Value prediction networks (VPNs, Oh et al., 2017) take a similar approach but use the model to construct a look-ahead tree only when constructing bootstrap targets and selecting actions, similarly to TD-search (Silver et al., 2012). Crucially, the model is not embedded in a planning algorithm during optimisation.
+
+We propose a new tree-structured neural network architecture to address the aforementioned problems. By formulating the tree look-ahead in a differentiable way and integrating it directly into the $Q$ - function or policy, we train the entire agent, including its learned transition model, end-to-end. This ensures that the model is optimised for the correct goal and is suitable for on-line planning during execution of the policy.
+
+Since the transition model is only weakly grounded in the actual environment, our approach can alternatively be viewed as a model-free method in which the fully connected layers of DQN are replaced by a recursive network that applies transition functions with shared parameters at each tree node expansion.
+
+The resulting architecture, which we call TreeQN, encodes an inductive bias based on the prior knowledge that the environment is a stationary Markov process, which facilitates faster learning of better policies. We also present an actor-critic variant, ATreeC, in which the tree is augmented with a softmax layer and used as a policy network.
+
+We show that TreeQN and ATreeC outperform their DQN-based counterparts in a box-pushing domain and a suite of Atari games, with deeper trees often outperforming shallower trees, and TreeQN outperforming VPN (Oh et al., 2017) on most Atari games. We also present ablation studies investigating various auxiliary losses for grounding the transition model more strongly in the environment, which could improve performance as well as lead to interpretable internal plans. While we show that grounding the reward function is valuable, we conclude that how to learn strongly grounded transition models and generate reliably interpretable plans without compromising performance remains an open research question.
+
+# 2 BACKGROUND
+
+We consider an agent learning to act in a Markovimising its expected discounted sum of rewards $\begin{array} { r } { R _ { t } = \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } r _ { t } } \end{array}$ s (MDP), with the goa, by learning a policy $\pi ( \mathbf { s } )$ max-that maps states to actions . The state-action value function $Q$ -function) is defined as $\begin{array} { r } { Q ^ { \pi } ( \mathbf { s } , a ) = \mathbb { E } _ { \pi } \left[ R _ { t } | \mathbf { s } _ { t } = \mathbf { s } , a _ { t } = a \right] } \end{array}$ ; the optimal $Q$ -function is $Q ^ { * } ( \mathbf { s } , a ) = \operatorname* { m a x } _ { \pi } Q ^ { \pi } ( \mathbf { s } , a )$ .
+
+The Bellman optimality equation writes $Q ^ { * }$ recursively as
+
+$$
+Q ^ { * } ( \mathbf { s } , a ) = T Q ^ { * } ( \mathbf { s } , a ) \equiv r ( \mathbf { s } , a ) + \gamma \sum _ { \mathbf { s ^ { \prime } } } P ( \mathbf { s } ^ { \prime } | \mathbf { s } , a ) \operatorname* { m a x } _ { a ^ { \prime } } Q ^ { * } ( \mathbf { s } ^ { \prime } , a ^ { \prime } ) ,
+$$
+
+where $P$ is the MDP state transition function and $r$ is a reward function, which for simplicity we assume to be deterministic. $Q$ -learning (Watkins $\&$ Dayan, 1992) uses a single-sample approximation of the contraction operator $\tau$ to iteratively improve an estimate of $Q ^ { * }$ .
+
+In deep $Q$ -learning (Mnih et al., 2015), $Q$ is represented by a deep neural network with parameters $\theta$ , and is improved by regressing $Q ( \mathbf { s } , a )$ to a target $r + \bar { \gamma } \operatorname* { m a x } _ { a ^ { \prime } } Q ( \mathbf { s } ^ { \prime } , a ^ { \prime } ; \theta ^ { - } )$ , where $\theta ^ { - }$ are the parameters of a target network periodically copied from $\theta$ .
+
+We use a version of $n$ -step $Q$ -learning (Mnih et al., 2016) with synchronous environment threads. In particular, starting at a timestep $t$ , we roll forward $n _ { \mathrm { e n v } } = 1 6$ threads for $n = 5$ timesteps each. We then bootstrap off the final states only and gather all $n _ { \mathrm { e n v } } \times n = 8 0$ transitions in a single batch for
+
+the backward pass, minimising the loss:
+
+$$
+\mathcal { L } _ { \mathrm { n s t e p . Q } } = \sum _ { \mathrm { e n v s } } \sum _ { j = 1 } ^ { n } \left( \sum _ { k = 1 } ^ { j } \left[ \gamma ^ { j - k } r _ { t + n - k } \right] + \gamma ^ { j } \operatorname* { m a x } _ { a ^ { \prime } } Q \left( \mathbf { s } _ { t + n } , a ^ { \prime } , \theta ^ { - } \right) - Q \left( \mathbf { s } _ { t + n - j } , a _ { t + n - j } , \theta \right) \right) ^ { 2 } .
+$$
+
+If the episode terminates, we use the remaining episode return as the target, without bootstrapping.
+
+This algorithm’s actor-critic counterpart is A2C, a synchronous variant of A3C (Mnih et al., 2016) in which a policy $\pi$ and state-value function $V ( s )$ are trained using the gradient:
+
+$$
+\Delta \theta = \sum _ { \mathrm { e n v s } } \sum _ { j = 1 } ^ { n } \nabla _ { \theta _ { \tau } } \log \pi ( a _ { t + n - j } | s _ { t + n - j } ) A _ { j } ( s _ { t + n - j } , a _ { t + n - j } ) + \beta \nabla _ { \theta _ { \tau } } H ( \pi ( s _ { t + n - j } ) )
+$$
+
+$$
++ \alpha \nabla _ { \theta _ { V } } A _ { j } ( s _ { t + n - j } , a _ { t + n - j } ) ^ { 2 } ,
+$$
+
+where $A _ { j }$ is an advantage estimate given by $\begin{array} { r } { \sum _ { k = 1 } ^ { j } \gamma ^ { j - k } r _ { t + n - k } + \gamma ^ { j } V ( \mathbf { s } _ { t + n } ) - V ( \mathbf { s } _ { t + n - j } ) , . } \end{array}$ $H$ is the policy entropy, $\beta$ is a hyperparameter tuning the degree of entropy regularisation, and $\alpha$ is a hyperparameter controlling the relative learning rates of actor and critic.
+
+These algorithms were chosen for their simplicity and reasonable wallclock speeds, but TreeQN can also be used in other algorithms, as described in Section 3. Our implementations are based on OpenAI Baselines (Hesse et al., 2017).
+
+The canonical neural network architecture in deep RL with visual observations has a series of convolutional layers followed by two fully connected layers, where the final layer produces one output for each action-value. We can think of this network as first calculating an encoding $\mathbf { z } _ { t }$ of the state $\mathbf { s } _ { t }$ which is then evaluated by the final layer to estimate $Q ^ { * } ( \mathbf { s } _ { t } , a )$ (see Fig. 1).
+
+![](images/a1c8aa777b391aa8e4813f2342fedb38e83445bf81cda679495660e595151def.jpg)  
+Figure 1: High-level structure of DQN.
+
+In tree-search on-line planning, a look-ahead tree of possible future states is constructed by recursively applying an environment model. These states are typically evaluated by a heuristic, a learned value function, or Monte-Carlo rollouts. Backups through the tree aggregate these values along with the immediate rewards accumulated along each path to estimate the value of taking an action in the current state. This paper focuses on a simple tree-search with a deterministic transition function and no value uncertainty estimates, but our approach can be extended to tree-search variants like UCT (Kocsis & Szepesvari´ , 2006; Silver et al., 2016) if the components remain differentiable.
+
+# 3 TREEQN
+
+In this section, we propose TreeQN, a novel end-to-end differentiable tree-structured architecture for deep reinforcement learning. We first give an overview of the architecture, followed by details of each model component and the training procedure.
+
+TreeQN uses a recursive tree-structured neural network between the encoded state $\mathbf { z } _ { t }$ and the predicted state-action values $Q ( \mathbf { s } _ { t } , a )$ , instead of directly estimating the state-action value from the current encoded state $\mathbf { z } _ { t }$ using fully connected layers as in DQN (Mnih et al., 2015). Specifically, TreeQN uses a recursive model to refine its estimate of $Q ( \mathbf { s } _ { t } , a )$ via learned transition, reward, and value functions, and a tree backup (see Fig. 2). Because these learned components are shared throughout the tree, TreeQN implements an inductive bias, missing from DQN, that reflects the prior knowledge that the $Q$ -values are properties of a stationary Markov process. We also encode the inductive bias that $Q$ -values may be expressed as a sum of scalar rewards and values.
+
+$\mathbf { z } _ { l \mid t }$ cifically, TreeQN learns an action-de, predicts the next state representation $\mathbf { z } _ { l + 1 | t } ^ { a _ { i } }$ t transitiofor action $a _ { i } \in { \mathcal { A } }$ n that, given a state representa, and the corresponding reward $\hat { r } _ { l | t } ^ { a _ { i } }$ To make the distinction between internal planning steps and steps taken in the environment explicit, we write $\mathbf { z } _ { l \mid t }$ to denote the encoded state at time $t$ after $l$ internal transitions, starting with ${ \bf z } _ { 0 \mid t }$ for the encoding of $\mathbf { s } _ { t }$ . TreeQN applies this transition function recursively to construct a tree containing the state representations and rewards received for all possible sequences of actions up to some predefined depth $d$ (“Tree Transitioning” in Fig. 2).
+
+![](images/e166e58c3a5bca1ad7d1969b9d7a51bd50882c1420e24550565fb81a4f0a5e82.jpg)  
+Figure 2: High-level structure of TreeQN with a tree depth of two and shared transition and evaluation functions (reward prediction and value mixing omitted for simplicity).
+
+The value of each predicted state $V ( \mathbf { z } )$ is estimated with a value function module. Using these values and the predicted rewards, TreeQN then performs a tree backup, mixing the $k$ -step returns along each path in the tree using $\mathrm { T D } ( \lambda )$ (Sutton, 1988; Sutton & Barto, 1998). This corresponds to “Value Prediction & Backup” in Fig. 2 and can be formalized as
+
+$$
+\begin{array} { r l } & { Q ^ { l } ( \mathbf { z } _ { l \mid t } , a _ { i } ) = r ( \mathbf { z } _ { l \mid t } , a _ { i } ) + \gamma V ^ { ( \lambda ) } ( \mathbf { z } _ { l + 1 \mid t } ) } \\ & { V ^ { ( \lambda ) } ( \mathbf { z } _ { l \mid t } ) = \left\{ V ( \mathbf { z } _ { l \mid t } ^ { a _ { i } } ) \right. \ } & { l = d } \\ & { \left. ( 1 - \lambda ) V ( \mathbf { z } _ { l \mid t } ^ { a _ { i } } ) + \lambda \mathrm { b } ( Q ^ { l + 1 } ( \mathbf { z } _ { l + 1 \mid t } ^ { a _ { i } } , a _ { j } ) ) \right. \ l < d } \end{array}
+$$
+
+where $\mathrm { b }$ is a function to recursively perform the backup. For $0 < \lambda < 1$ , value estimates of the intermediate states are mixed into the final $Q$ -estimate, which encourages the intermediate nodes of the tree to correspond to meaningful states, and reduces the impact of outlier values.
+
+When $\lambda = 1$ , and $\mathrm { b }$ is the standard hard max function, then Eq. 3 simplifies to a backup through the tree using the familiar Bellman equation:
+
+$$
+Q ( \mathbf { z } _ { l | t } , a _ { i } ) = r ( \mathbf { z } _ { l | t } , a _ { i } ) + \left\{ \begin{array} { l l } { \gamma V ( \mathbf { z } _ { d | t } ^ { a _ { i } } ) } & { l = d - 1 } \\ { \gamma \operatorname* { m a x } _ { a _ { j } } Q ( \mathbf { z } _ { l + 1 | t } ^ { a _ { i } } , a _ { j } ) } & { l < d - 1 . } \end{array} \right.
+$$
+
+We note that even for a tree depth of only one, TreeQN imposes a significant structure on the value function by decomposing it as a sum of action-conditional reward and next-state value, and using a shared value function to evaluate each next-state representation.
+
+Crucially, during training we backpropagate all the way from the final $Q$ -estimate, through the value prediction, tree transitioning, and encoding layers of the tree, i.e., the entire network shown in Fig. 2. Learning these components jointly ensures that they are useful for planning on-line.
+
+# 3.1 MODEL COMPONENTS
+
+In this section, we describe each of TreeQN’s components in more detail.
+
+Encoder function. As in DQN, a series of convolutional layers produces an embedding of the observed state, $\mathbf { z } _ { 0 \mid t } = \mathsf { e n c o d e } ( \mathbf { s } _ { t } )$ .
+
+Transition function. We first apply a single fully connected layer to the current state embedding, shared by all actions. This generates an intermediate representation $( \mathbf z _ { l + 1 | t } ^ { \mathrm { e n v } } )$ that could carry information about action-agnostic changes to the environment. In addition, we use a fully connected layer per action, which is applied to the intermediate representation to calculate a next-state representation that carries information about the effect of taking action $a _ { i }$ . We use residual connections for these layers:
+
+$$
+\begin{array} { r l } & { \mathbf { z } _ { l + 1 \mid t } ^ { \mathrm { e n v } } = \mathbf { z } _ { l \mid t } + \operatorname { t a n h } ( W ^ { \mathrm { e n v } } \mathbf { z } _ { l \mid t } + \mathbf { b } ^ { \mathrm { e n v } } ) , } \\ & { \mathbf { z } _ { l + 1 \mid t } ^ { a _ { i } } = \mathbf { z } _ { l + 1 \mid t } ^ { \mathrm { e n v } } + \operatorname { t a n h } ( W ^ { a _ { i } } \mathbf { z } _ { l + 1 \mid t } ^ { \mathrm { e n v } } ) , } \end{array}
+$$
+
+where $W ^ { a _ { i } } , W ^ { \mathrm { e n v } } \in \mathbb R ^ { k \times k } , \mathbf { b } ^ { \mathrm { e n v } } \in \mathbb R ^ { k }$ are learnable parameters. Note that the next-state representation is calculated for every action $a _ { i }$ independently using the respective transition matrix $W ^ { a _ { i } }$ , but this transition function is shared for the same action throughout the tree.
+
+A caveat is that the model can still learn to use different parts of the latent state space in different parts of the tree, which could undermine the intended parameter sharing in the model structure. To help TreeQN learn useful transition functions that maintain quality and diversity in their latent states, we introduce a unit-length projection of the state representations by simply dividing a state’s vector representation by its L2 norm before each application of the transition function, $\mathbf { z } _ { l | t } : = \mathbf { z } _ { l | t } / \left| \left| \mathbf { z } _ { l | t } \right| \right|$ This prevents the magnitude of the representation from growing or shrinking, which encourages the behaviour of the transition function to be more consistent throughout the tree.
+
+Reward function. In addition to predicting the next state, we also predict the immediate reward for every action $a _ { i } \in { \mathcal { A } }$ in state $\mathbf { z } _ { l \mid t }$ using
+
+$$
+\hat { \mathbf { r } } ( \mathbf { z } _ { l \mid t } ) = W _ { 2 } ^ { r } \mathrm { R e L U } ( W _ { 1 } ^ { r } \mathbf { z } _ { l \mid t } + \mathbf { b } _ { 1 } ^ { r } ) + \mathbf { b } _ { 2 } ^ { r } ,
+$$
+
+where $W _ { 1 } ^ { r } \in \mathbb { R } ^ { m \times k }$ , $W _ { 2 } ^ { r } \in \mathbb { R } ^ { | \mathcal { A } | \times m }$ and ReLU is the rectified linear unit (Nair & Hinton, 2010), and the predicted reward for a particular action $\hat { r } _ { l | t } ^ { a _ { i } }$ is the $i$ -th element of the vector $\hat { \mathbf { r } } ( \mathbf { z } _ { l \mid t } )$ .
+
+Value function. The value of a state representation $\mathbf { z }$ is estimated as
+
+$$
+V ( \mathbf { z } ) = \mathbf { w } ^ { \top } \mathbf { z } + b ,
+$$
+
+where $\mathbf { w } \in \mathbb { R } ^ { k }$
+
+Backup function. We use the following function that can be recursively applied to calculate the tree backup:
+
+$$
+\mathrm { b } ( \mathbf { x } ) = \sum _ { i } x _ { i } \mathrm { s o f t m a x } ( \mathbf { x } ) _ { i } .
+$$
+
+Using a hard max for calculating the backup would result in gradient information only being used to update parameters along the maximal path in the tree. By contrast, the softmax allows us to use downstream gradient information to update parameters along all paths. Furthermore, it potentially reduces the impact of outlier value predictions. With a learned temperature for the softmax, this function could represent the hard max arbitrarily closely. However, we did not find an empirical difference so we left the temperature at 1.
+
+# 3.2 GROUNDING THE MODEL COMPONENTS
+
+The TreeQN architecture is fully differentiable, so we can directly use it in the place of a $Q$ -function in any deep RL algorithm with discrete actions. Differentiating through the entire tree ensures that the learned components are useful for planning on-line, as long as that planning is performed in the same way as during training.
+
+However, it seems plausible that auxiliary objectives based on minimising the error in predicting rewards or observations could improve the performance by helping to ground the transition and reward functions to the environment. It could also encourage TreeQN to perform model-based planning in an interpretable manner. In principle, such objectives could give rise to a spectrum of methods from model-free to fully model-based. At one extreme, TreeQN without auxiliary objectives can be seen as a model-free approach that draws inspiration from tree-search planning to encode valuable inductive biases into the neural network architecture. At the other extreme, perfect, grounded reward and transition models could in principle be learned. Using them in our architecture would then correspond to standard model-based lookahead planning. The sweet spot could be an intermediate level of grounding that maintains the flexibility of end-to-end model-free learning while benefiting from the additional supervision of explicit model learning. To investigate this spectrum, we experiment with two auxiliary objectives.
+
+Reward grounding. We experiment with an L2 loss regressing rˆat:t+l−1| , the predicted reward at level $l$ of the tree corresponding to the selected action sequence $\left\{ a _ { t } \ldots a _ { t + l - 1 } \right\}$ , to the true observed rewards. For each of the $n$ timesteps of $n$ -step Q-learning this gives:
+
+$$
+\mathcal { L } = \mathcal { L } _ { \mathrm { n s t e p } \cdot \mathrm { Q } } + \eta _ { r } \sum _ { \mathrm { e n v s } } \sum _ { j = 1 } ^ { n } \sum _ { l = 1 } ^ { \bar { d } } \left( \hat { r } _ { l \mid t + j } ^ { a _ { t + j : t + j + l - 1 } } - r _ { t + j + l - 1 } \right) ^ { 2 } ,
+$$
+
+where $\eta _ { r }$ is a hyperparameter weighting the loss, and $\bar { d } = \operatorname* { m i n } ( d , n - j + 1 )$ restricts the sum to rewards for which we have already observed the true value.
+
+State grounding. We experiment with a grounding in the latent space, using an L2 loss to regress the predicted latent state $\mathbf { z } _ { l \mid t } ^ { a _ { t : t + l } }$ at level $l$ of the tree to $\mathbf { z } _ { 0 \mid t + l }$ , the initial encoding of the true state corresponding to the actions actually taken:
+
+$$
+\mathcal { L } = \mathcal { L } _ { \mathrm { n s t e p } \cdot \mathrm { Q } } + \eta _ { s } \sum _ { \mathrm { e n v s } } \sum _ { j = 1 } ^ { n } \sum _ { l = 1 } ^ { \bar { d } } \left( \mathbf { z } _ { l \mid t + j } ^ { a _ { t + j : t + j + l - 1 } } - \mathbf { z } _ { 0 \mid t + j + l } \right) ^ { 2 } .
+$$
+
+By employing an additional decoder module, we could use a similar loss to regress decoded observations to the true observations. In informal experiments, joint training with such a decoder loss did not yield good performance, as also found by Oh et al. (2017).
+
+In Section 7.1, we present results on the use these objectives, showing that reward grounding gives better performance, but that our method for state grounding does not.
+
+# 4 ATREEC
+
+The intuitions guiding the design of TreeQN are as applicable to policy search as to valuebased RL, in that a policy can use a tree planner to improve its estimates of the optimal action probabilities (Gelly & Silver, 2007; Silver et al., 2017a). As our proposed architecture is trained end-to-end, it can be easily adapted for use as a policy network.
+
+In particular, we propose ATreeC, an actor-critic extension of TreeQN. In this architecture, the policy network is identical to TreeQN, with an additional softmax layer that converts the $Q$ estimates into the probabilities of a stochastic policy.
+
+![](images/c25055870dfdd057fb07bebcc4851a33c1d3f8f989097e46a5424ba4be71f1b0.jpg)  
+Figure 3: High-level structure of ATreeC.
+
+The critic shares the encoder parameters, and predicts a scalar state value with a single fully connected layer: $V _ { \mathrm { c r } } ( \mathbf { s } ) = \mathbf { w } _ { \mathrm { c r } } ^ { \top } \mathbf { z } + b _ { \mathrm { c r } }$ . We used different parameters for the critic value function and the actor’s tree-value-function module, but found that sharing these parameters had little effect on performance. The entire setup, shown in Fig. 3, is trained with A2C as described in Section 2, with the addition of the same auxiliary losses used for TreeQN. Note that TreeQN could also be used in the critic, but we leave this possibility to future work.
+
+# 5 RELATED WORK
+
+There is a long history of work combining model-based and model-free RL. An early example is Dyna-Q (Sutton, 1990) which trains a model-free algorithm with samples drawn from a learned model. Similarly, van Seijen et al. (2011) train a sparse model with some environment samples that can be used to refine a model-free $Q$ -function. Gu et al. (2016) use local linear models to generate additional samples for their model-free algorithm. However, these approaches do not attempt to use the model on-line to improve value estimates.
+
+In deep RL, value iteration networks (Tamar et al., 2016) use a learned differentiable model to plan on the fly, but require planning over the full state space, which must also possess a spatial structure with local dynamics such that convolution operations can execute the planning algorithm.
+
+The predictron (Silver et al., 2017b) instead learns abstract-state transition functions in order to predict values. However, it is restricted to policy evaluation without control. Value prediction networks (VPNs, Oh et al., 2017) take a similar approach but are more closely related to our work because the learned model components are used in a tree for planning. However, in their work this tree is only used to construct targets and choose actions, and not to compute the value estimates during training. Such estimates are instead produced from non-branching trajectories following on-policy action sequences. By contrast, TreeQN is a unified architecture that constructs the tree dynamically at every timestep and differentiates through it, eliminating any mismatch between the model at training and test time. Furthermore, we do not use convolutional transition functions, and hence do not impose spatial structure on the latent state representations. These differences simplify training, allow our model to be used more flexibly in other training regimes, and explain in part our substantially improved performance on the Atari benchmark.
+
+Donti et al. (2017) propose differentiating through a stochastic programming optimisation using a probabilistic model to learn model parameters with respect to their true objective rather than a maximum likelihood surrogate. However, they do not tackle the full RL setting, and do not use the model to repeatedly or recursively refine predictions.
+
+Imagination-augmented agents (Weber et al., 2017) learn to improve policies by aggregating rollouts predicted by a model. However, they rely on pretraining an observation-space model, which we argue will scale poorly to more complex environments. Further, their aggregation of rollout trajectories takes the form of a generic RNN rather than a value function and tree backup, so the inductive bias based on the structure of the MDP is not explicitly present.
+
+A class of value gradient methods (Deisenroth & Rasmussen, 2011; Fairbank & Alonso, 2012; Heess et al., 2015) also differentiates through models to train a policy. However, this approach does not use the model during execution to refine the policy, and requires continuous action spaces.
+
+Oh et al. (2015) and Chiappa et al. (2017) propose methods for learning observation-prediction models in the Atari domain, but use these models only to improve exploration. Variants of scheduled sampling (Bengio et al., 2015) may be used to improve robustness of these models, but scaling to complex domains has proven challenging (Talvitie, 2014).
+
+# 6 EXPERIMENTS
+
+We evaluate TreeQN and ATreeC in a simple box-pushing environment, as well as on the subset of nine Atari environments that Oh et al. (2017) use to evaluate VPN. The experiments are designed to determine whether or not TreeQN and ATreeC outperform DQN, A2C, and VPN, and whether they can scale to complex domains. We also investigate how to best ground the the transition function with auxiliary losses. Furthermore, we compare against alternative ways to increase the number of parameters and computations of a standard DQN architecture, and study the impact of tree depth. Full details of the experimental setup, as well as architecture and training hyperparameters, are given in the appendix.
+
+Grounding. We perform a hyperparameter search over the coefficients $\eta _ { r }$ and $\eta _ { s }$ of the reward and state grounding auxiliary losses, on the Atari environment Seaquest. These experiments aim to determine the relevant trade-offs between the flexibility of a model-free approach and the potential benefits of a more model-based algorithm.
+
+Box Pushing. We randomly place an agent, 12 boxes, 5 goals and 6 obstacles on the center $6 \times 6$ tiles of an $8 \times 8$ grid. The agent’s goal is to push boxes into goals in as few steps as possible while avoiding obstacles. Boxes may not be pushed into each other. The obstacles, however, are ‘soft’ in that they are do not block movement, but generate a negative reward if the agent or a box moves onto an obstacle. This rewards better planning without causing excessive gridlock. This environment is inspired by Sokoban, as used by Weber et al. (2017), in that poor actions can generate irreversibly bad configurations. However, the level generation process for Sokoban is challenging to reproduce exactly and has not been open-sourced. More details of the environment and rewards are given in Appendix A.1.
+
+![](images/97da6ea8c2b8e8eaa44c239e1def910645c5c0d4ba1ee593d6f68ab36d648d3a.jpg)  
+Figure 4: Grounding the reward and transition functions using auxiliary losses: final returns on Seaquest plotted against the coefficient of the auxiliary loss.
+
+Atari. To demonstrate the general applicability of TreeQN and ATreeC to complex environments, we evaluate them on the Atari 2600 suite (Bellemare et al., 2013). Following Oh et al. (2017), we use their set of nine environments and a frameskip of 10 to facilitate planning over reasonable timescales.
+
+TreeQN adds additional parameters to a standard DQN architecture. We compare TreeQN to two baseline architectures with increased computation and numbers of parameters to verify the benefit of the additional structure and grounding. DQN-Wide doubles the size of the embedding dimension (1024 instead of 512). DQN-Deep inserts two additional fully connected layers with shared parameters and residual connections between the two fully-connected layers of DQN. This is in effect a non-branching version of the TreeQN architecture that also lacks explicit reward prediction.
+
+# 7 RESULTS & DISCUSSION
+
+In this section, we present our experimental results for TreeQN and ATreeC.
+
+# 7.1 GROUNDING
+
+Fig. 4 shows the result of a hyperparameter search on $\eta _ { r }$ and $\eta _ { s }$ , the coefficients of the auxiliary losses on the predicted rewards and latent states. An intermediate value of $\eta _ { r }$ helps performance but there is no benefit to using the latent space loss. Subsequent experiments use $\eta _ { r } = 1$ and $\eta _ { s } = 0$ .
+
+The predicted rewards that the reward-grounding objective encourages the model to learn appear both in its own $Q$ -value prediction and in the target for $n$ -step $Q$ -learning. Consequently, we expect this auxiliary loss to be well aligned with the true objective. By contrast, the state-grounding loss (and other potential auxiliary losses) might help representation learning but would not explicitly learn any part of the desired target. It is possible that this mismatch between the auxiliary and primary objective leads to degraded performance when using this form of state grounding. One potential route to overcoming this obstacle to joint training would be pre-training a model, as done by Weber et al. (2017). Inside TreeQN this model could then be fine-tuned to perform well inside the planner. We leave this possiblity to future work.
+
+# 7.2 BOX PUSHING
+
+Fig. 5a shows the results of TreeQN with tree depths 1, 2, and 3, compared to a DQN baseline. In this domain, there is a clear advantage for the TreeQN architecture over DQN. TreeQN learns policies that are substantially better at avoiding obstacles and lining boxes up with goals so they can be easily pushed in later. TreeQN also substantially speeds up learning. We believe that the greater structure brought by our architecture regularises the model, encouraging appropriate state representations to be learned quickly. Even a depth-1 tree improves performance significantly, as disentangling the estimation of rewards and next-state values makes them easier to learn. This is further facilitated by the sharing of value-function parameters across branches.
+
+![](images/bbb23d8d559767eabf733b8c2ecddefc93e437f2c2583281060880ce9d7b044a.jpg)  
+Figure 5: Box-pushing results: the $x$ -axis shows the number of transitions observed across all of the synchronous environment threads.
+
+When trained with $n$ -step Q-learning, the deeper depth-2 and depth-3 trees learn faster and plateau higher than the shallow depth-1 tree. In the this domain, useful transition functions are relatively easy to learn, and the extra computation time with those transition modules can help refine value estimates, yielding advantages for additional depth.
+
+Fig. 5b shows the results of ATreeC with tree depths 1, 2, and 3, compared to an A2C baseline. As with TreeQN, ATreeC substantially outperforms the baseline. Furthermore, thanks to its stochastic policy, it substantially outperforms TreeQN. Whereas TreeQN and DQN sometimes indecisively bounce back and forth between adjacent states, ATreeC captures this uncertainty in its policy probabilities and thus acts more decisively. However, unlike TreeQN, ATreeC shows no pronounced differences for different tree depths. This is in part due to a ceiling effect in this domain. However, ATreeC is also gated by the quality of the critic’s value function, which in these experiments was a single linear layer after the state encoding as described in Section 4. Nonetheless, this result demonstrates the ease with which TreeQN can be used as a drop-in replacement for any deep RL algorithm that learns policies or value functions for discrete actions.
+
+# 7.3 ATARI
+
+Table 1 summarises all our Atari results, while Fig. 6 shows learning curves in depth. TreeQN shows substantial benefits in many environments compared to our DQN baseline, which itself often outperforms VPN (Oh et al., 2017). ATreeC always matches or outperforms A2C. We present the mean performance of five random seeds, while the VPN results reported by Oh et al. (2017), shown as dashed lines in Fig. 6, are the mean of the best five seeds of an unspecified number of trials.
+
+TreeQN. In all environments except Frostbite, TreeQN outperforms DQN on average, with the most significant gains in Alien, CrazyClimber, Enduro, Krull, and Seaquest. Many of these environments seem well suited to short horizon look-ahead planning, with simple dynamics that generalise well and tradeoffs between actions that become apparent only after several timesteps. For example, an incorrect action in Alien can trap the agent down a corridor with an alien. In Seaquest, looking ahead could help determine whether it is better to go deeper to collect more points or to surface for oxygen. However, even in a game with mostly reactive decisions like the racing game Enduro, TreeQN shows significant benefits.
+
+TreeQN also outperforms the additional baselines of DQN-Wide and DQN-Deep, indicating that the additional structure and grounding of our architecture brings benefits beyond simply adding model capacity and computation. In particular, it is interesting that DQN-Deep is often outperformed by the vanilla DQN baseline, as optimisation difficulties grow with depth. In contrast, the additional structure and auxiliary loss employed by TreeQN turn its additional depth from a liability into a strength.
+
+![](images/8a8b0162732a2a7f45e78c6ce7220ef0c080f2a73238d623627d2ab9ddf1a446.jpg)  
+Figure 6: Results for the Atari domain. The y-axis shows the moving average over 100 episodes. Each of five random seeds is plotted faintly, with the mean in bold.
+
+Table 1: Summary of Atari results. Each number is the best score throughout training, calculated as the mean of the last 100 episode rewards averaged over exactly five agents trained with different random seeds. Note that Oh et al. (2017) report the same statistic, but average instead over the best five of an unspecified number of agents.   
+
+<table><tr><td></td><td>Alien</td><td>Amidar</td><td>Crazy Climber</td><td>Enduro</td><td>Frostbite</td><td>Krull</td><td>Ms.Pacman</td><td>Q*Bert</td><td>Seaquest</td></tr><tr><td>DQN (Oh et al., 2017)</td><td>1804</td><td>535</td><td>41658</td><td>326</td><td>3058</td><td>12438</td><td>2804</td><td>12592</td><td>2951</td></tr><tr><td>VPN (Oh et al.,2017)</td><td>1429</td><td>641</td><td>54119</td><td>382</td><td>3811</td><td>15930</td><td>2689</td><td>14517</td><td>5628</td></tr><tr><td>n-step DQN</td><td>1969</td><td>1033</td><td>71623</td><td>625</td><td>3968</td><td>7860</td><td>2774</td><td>14468</td><td>3465</td></tr><tr><td>DQN-Deep</td><td>1906</td><td>825</td><td>53101</td><td>745</td><td>493</td><td>8605</td><td>2410</td><td>15094</td><td>3575</td></tr><tr><td>DQN-Wide</td><td>2187</td><td>1074</td><td>91380</td><td>682</td><td>3493</td><td>6603</td><td>3061</td><td>15794</td><td>3909</td></tr><tr><td>TreeQN-1</td><td>2321</td><td>1030</td><td>107983</td><td>800</td><td>2254</td><td>10836</td><td>3030</td><td>15688</td><td>9302</td></tr><tr><td>TreeQN-2</td><td>2497</td><td>1170</td><td>104932</td><td>825</td><td>581</td><td>11035</td><td>3277</td><td>15970</td><td>8241</td></tr><tr><td>A2C</td><td>2673</td><td>1525</td><td>102776</td><td>642</td><td>297</td><td>5784</td><td>4352</td><td>24451</td><td>1734</td></tr><tr><td>ATreeC-1</td><td>3448</td><td>1578</td><td>102546</td><td>678</td><td>1035</td><td>8227</td><td>4866</td><td>25159</td><td>1734</td></tr><tr><td>ATreeC-2</td><td>2813</td><td>1566</td><td>110712</td><td>649</td><td>281</td><td>8134</td><td>4450</td><td>25459</td><td>2176</td></tr></table>
+
+ATreeC. ATreeC matches or outperforms its baseline (A2C) in all environments. Compared to TreeQN, ATreeC’s performance is better across most environments, particularly on Qbert, reflecting an overall advantage for actor-critic also found by Mnih et al. (2016) and in our box-pushing experiments. However, performance is much worse on Seaquest, revealing a deficiency in exploration as policy entropy collapses too rapidly and consequently the propensity of policy gradient methods to become trapped in a local optimum.
+
+In Krull and Frostbite, most algorithms have poor performance, or high variance in returns from run to run, as agents are gated by their ability to explore. Both of these games require the completion of sub-levels in order to accumulate large scores, and none of our agents reliably explore beyond the initial stages of the game. Mean performance appears to favor TreeQN and ATreeC in Krull, and perhaps DQN in Frostbite, but the returns are too variable to draw conclusions from this number of random seeds. Combining TreeQN and ATreeC with smart exploration mechanisms is an interesting direction for future work to improve robustness of training in these types of environments.
+
+Compared to the box-pushing domain, there is less of a clear performance difference between trees of different depths. In some environments (Amidar, MsPacman), greater depth does appear to be employed usefully by TreeQN to a small extent, resulting in the best-performing individual agents. However, for the Atari domain the embedding size for the transition function we use is much larger (512 compared to 128), and the dynamics are much more complex. Consequently, we expect that optimisation difficulties, and the challenge of learning abstract-state transition functions, impede the utility of deeper trees in some cases. We look to future work to further refine methods for learning to plan abstractly in complex domains. However, the decomposition of Q-value into reward and next-state value employed by the first tree expansion is clearly of utility in a broad range of tasks.
+
+When inspecting the learned policies and trees, we find that the values sometimes correspond to intuitive reasoning about sensible policies, scoring superior action sequences above poorer ones. However, we find that the actions corresponding to branches of the tree that are scored most highly are frequently not taken in future timesteps. The flexibility of TreeQN and ATreeC allows our agents to find any useful way to exploit the computation in the tree to refine action-value estimates. As we found no effective way to strongly ground the model components without sacrificing performance, the interpretability of learned trees is limited.
+
+# 8 CONCLUSIONS & FUTURE WORK
+
+We presented TreeQN and ATreeC, new architectures for deep reinforcement learning in discreteaction domains that integrate differentiable on-line tree planning into the action-value function or policy. Experiments on a box-pushing domain and a set of Atari games show the benefit of these architectures over their counterparts, as well as over VPN. In future work, we intend to investigate enabling more efficient optimisation of deeper trees, encouraging the transition functions to produce interpretable plans, and integrating smart exploration.
+
+# ACKNOWLEDGMENTS
+
+We thank Sasha Salter, Luisa Zintgraf, and Wendelin Bohmer for their contributions and valuable ¨ comments on drafts of this paper. This work was supported by the UK EPSRC CDT in Autonomous Intelligent Machines and Systems. This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement #637713). The NVIDIA DGX-1 used for this research was donated by the NVIDIA Corporation.
+
+# REFERENCES
+
+Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1171–1179, 2015.
+
+Cameron B Browne, Edward Powley, Daniel Whitehouse, Simon M Lucas, Peter I Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of monte carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in games, 4(1):1–43, 2012.
+
+Silvia Chiappa, Sebastien Racaniere, Daan Wierstra, and Shakir Mohamed. Recurrent environment ´ simulators. arXiv preprint arXiv:1704.02254, 2017.
+
+Remi Coulom. Efficient selectivity and backup operators in monte-carlo tree search. In ´ Computers and Games, 5th International Conference, CG 2006, Turin, Italy, May 29-31, 2006. Revised Papers, pp. 72–83, 2006. doi: 10.1007/978-3-540-75538-8 7.
+
+Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011.
+
+Priya L Donti, Brandon Amos, and J Zico Kolter. Task-based end-to-end model learning. arXiv preprint arXiv:1703.04529, 2017.
+
+Michael Fairbank and Eduardo Alonso. Value-gradient learning. In Neural Networks (IJCNN), The 2012 International Joint Conference on, pp. 1–8. IEEE, 2012.
+
+Sylvain Gelly and David Silver. Combining online and offline knowledge in uct. In Proceedings of the 24th international conference on Machine learning, pp. 273–280. ACM, 2007.
+
+Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In International Conference on Machine Learning, pp. 2829–2838, 2016.
+
+Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015.
+
+Christopher Hesse, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Openai baselines. https://github.com/openai/baselines, 2017.
+
+Donald E Knuth and Ronald W Moore. An analysis of alpha-beta pruning. Artificial intelligence, 6 (4):293–326, 1975.
+
+Levente Kocsis and Csaba Szepesvari. Bandit based monte-carlo planning. In ´ Machine Learning: ECML 2006, 17th European Conference on Machine Learning, Berlin, Germany, September 18-22, 2006, Proceedings, pp. 282–293, 2006. doi: 10.1007/11871842 29.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. doi: 10.1038/nature14236.
+
+Volodymyr Mnih, Adria Puigdom \` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim \` Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, pp. 1928–1937, 2016.
+
+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.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In Advances in Neural Information Processing Systems, pp. 2863–2871, 2015.
+
+Junhyuk Oh, Satinder Singh, and Honglak Lee. Value prediction network. arXiv preprint arXiv:1707.03497, 2017.
+
+Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. arXiv preprint arXiv:1705.05363, 2017.
+
+David Silver, Richard S. Sutton, and Martin Muller. Temporal-difference search in computer go.¨ Machine Learning, 87(2):183–219, 2012. doi: 10.1007/s10994-012-5280-0.
+
+David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. doi: 10.1038/nature16961.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017a.
+
+David Silver, Hado van Hasselt, Matteo Hessel, Tom Schaul, Arthur Guez, Tim Harley, Gabriel Dulac-Arnold, David P. Reichert, Neil Rabinowitz, Andre Barreto, and Thomas Degris. The ´ predictron: End-to-end learning and planning. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 3191–3199, 2017b.
+
+Nathan R Sturtevant. An analysis of uct in multi-player games. In International Conference on Computers and Games, pp. 37–49. Springer, 2008.
+
+Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3 (1):9–44, 1988.
+
+Richard S. Sutton. Integrated architectures for learning, planning, and reacting based on approximating dynamic programming. In Machine Learning, Proceedings of the Seventh International Conference on Machine Learning, Austin, Texas, USA, June 21-23, 1990, pp. 216–224, 1990.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998.
+
+Erik Talvitie. Model regularization for stable sample rollouts. In UAI, pp. 780–789, 2014.
+
+Erik Talvitie. Self-correcting models for model-based reinforcement learning. In AAAI, pp. 2597– 2603, 2017.
+
+Aviv Tamar, Sergey Levine, Pieter Abbeel, Yi Wu, and Garrett Thomas. Value iteration networks. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pp. 2146–2154, 2016.
+
+Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26–31, 2012.
+
+Harm van Seijen, Shimon Whiteson, Hado van Hasselt, and Marco Wiering. Exploiting best-match equations for efficient reinforcement learning. Journal of Machine Learning Research, 12(Jun): 2045–2094, 2011.
+
+Christopher J. C. H. Watkins and Peter Dayan. Q-learning. Machine Learning, 8:279–292, 1992. doi: 10.1007/BF00992698.
+
+Theophane Weber, Sebastien Racani ´ ere, David P. Reichert, Lars Buesing, Arthur Guez, \` Danilo Jimenez Rezende, Adria Puigdom \` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, \` Razvan Pascanu, Peter Battaglia, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. CoRR, abs/1707.06203, 2017.
+
+# A APPENDIX
+
+# A.1 BOX PUSHING
+
+Environment. For each episode, a new level is generated by placing an agent, 12 boxes, 5 goals and 6 obstacles in the center $6 \times 6$ tiles of an $8 \times 8$ grid, sampling locations uniformly. The outer tiles are left empty to prevent initial situations where boxes cannot be recovered.
+
+The agent may move in the four cardinal directions. If the agent steps off the grid, the episode ends and the agent receives a penalty of $- 1$ . If the agent moves into a box, it is pushed in the direction of movement. Moving a box out of the grid generates a penalty of $- 0 . 1$ . Moving a box into another box is not allowed and trying to do so generates a penalty of $- 0 . 1$ while leaving all positions unchanged. When a box is pushed into a goal, it is removed and the agent receives a reward of $+ 1$ .
+
+Obstacles generate a penalty of $- 0 . 2$ when the agent or a box is moved onto them. Moving the agent over goals incurs no penalty. Lastly, at each timestep the agent receives a penalty of $- 0 . 0 1$ . Episodes terminate when 75 timesteps have elapsed, the agent has left the grid, or no boxes remain.
+
+The observation is given to the model as a tensor of size $5 \times 8 \times 8$ . The first four channels are binary encodings of the position of the agent, goals, boxes, and obstacles respectively. The final channel is filled with the number of timesteps remaining (normalised by the total number of timesteps allowed).
+
+Architecture. The encoder consists of (conv-3x3-1-24, conv-3x3-1-24, conv-4x4-1-48, fc-128), where conv-wxh-s-n denotes a convolution with $n$ filters of size $w \times h$ and stride $s$ , and fc-h denotes a fully connected layer with $h$ hidden units. All layers are separated with ReLU nonlinearities. The hidden layer of the reward function MLP has 64 hidden units.
+
+# A.2 ATARI
+
+Preprocessing of inputs follows the procedure of Mnih et al. (2015), including concatenation of the last four frames as input, although we use a frameskip of 10.
+
+Architecture. The Atari experiments have the same architecture as for box-pushing, except for the encoder architecture which is as follows: (conv-8x8-4-16, conv-4x4-2-32, fc-512).
+
+# A.3 OTHER HYPERPARAMETERS
+
+All experiments use RMSProp (Tieleman & Hinton, 2012) with a learning rate of 1e-4, a decay of $\alpha = 0 . 9 9$ , and $\epsilon = 1 \mathrm { e } { - } 5$ .
+
+The learning rate was tuned coarsely by running DQN on the Seaquest environment, and kept the same for all subsequent experiments (box-pushing and Atari).
+
+For DQN and TreeQN, $\epsilon$ for $\epsilon$ -greedy exploration was decayed linearly from 1 to 0.05 over the first 4 million environment transitions observed (after frameskipping, so over 40 million atomic Atari timesteps).
+
+For A2C and ATreeC, we use a value-function loss coefficient $\alpha = 0 . 5$ and an entropy regularisation $\beta = 0 . 0 1$ .
+
+The reward prediction loss was scaled by $\eta _ { r } = 1$
+
+We use $n _ { \mathrm { s t e p s } } = 5$ and $n _ { \mathrm { e n v s } } = 1 6$ , for a total batch size of 80.
+
+The discount factor is $\gamma = 0 . 9 9$ and the target networks are updated every $4 0 , 0 0 0$ environment transitions.

parse/train/H1dh6Ax0Z/H1dh6Ax0Z_content_list.json

@@ -0,0 +1,2034 @@
+[
+    {
+        "type": "text",
+        "text": "TREEQN AND ATREEC: DIFFERENTIABLE TREE-STRUCTURED MODELS FOR DEEP REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Gregory Farquhar1 gregory.farquhar@cs.ox.ac.uk ",
+        "bbox": [
+            184,
+            194,
+            459,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Tim Rocktaschel¨ 1 tim.rocktaschel@cs.ox.ac.uk ",
+        "bbox": [
+            547,
+            195,
+            813,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Maximilian Igl1 maximilian.igl@cs.ox.ac.uk ",
+        "bbox": [
+            184,
+            243,
+            441,
+            273
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shimon Whiteson1 shimon.whiteson@cs.ox.ac.uk ",
+        "bbox": [
+            547,
+            244,
+            813,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1University of Oxford, United Kingdom ",
+        "bbox": [
+            186,
+            292,
+            447,
+            308
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            345,
+            544,
+            361
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Combining deep model-free reinforcement learning with on-line planning is a promising approach to building on the successes of deep RL. On-line planning with look-ahead trees has proven successful in environments where transition models are known a priori. However, in complex environments where transition models need to be learned from data, the deficiencies of learned models have limited their utility for planning. To address these challenges, we propose TreeQN, a differentiable, recursive, tree-structured model that serves as a drop-in replacement for any value function network in deep RL with discrete actions. TreeQN dynamically constructs a tree by recursively applying a transition model in a learned abstract state space and then aggregating predicted rewards and state-values using a tree backup to estimate $Q$ -values. We also propose ATreeC, an actor-critic variant that augments TreeQN with a softmax layer to form a stochastic policy network. Both approaches are trained end-to-end, such that the learned model is optimised for its actual use in the tree. We show that TreeQN and ATreeC outperform $n$ -step DQN and A2C on a box-pushing task, as well as $n$ -step DQN and value prediction networks (Oh et al., 2017) on multiple Atari games. Furthermore, we present ablation studies that demonstrate the effect of different auxiliary losses on learning transition models. ",
+        "bbox": [
+            233,
+            377,
+            766,
+            613
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            641,
+            336,
+            656
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A promising approach to improving model-free deep reinforcement learning (RL) is to combine it with on-line planning. The model-free value function can be viewed as a rough global estimate which is then locally refined on the fly for the current state by the on-line planner. Crucially, this does not require new samples from the environment but only additional computation, which is often available. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            728
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One strategy for on-line planning is to use look-ahead tree search (Knuth & Moore, 1975; Browne et al., 2012). Traditionally, such methods have been limited to domains where perfect environment simulators are available, such as board or card games (Coulom, 2006; Sturtevant, 2008). However, in general, models for complex environments with high dimensional observation spaces and complex dynamics must be learned from agent experience. Unfortunately, to date, it has proven difficult to learn models for such domains with sufficient fidelity to realise the benefits of look-ahead planning (Oh et al., 2015; Talvitie, 2017). ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "A simple approach to learning environment models is to maximise a similarity metric between model predictions and ground truth in the observation space. This approach has been applied with some success in cases where model fidelity is less important, e.g., for improving exploration (Chiappa et al., 2017; Oh et al., 2015). However, this objective causes significant model capacity to be devoted to predicting irrelevant aspects of the environment dynamics, such as noisy backgrounds, at the expense of value-critical features that may occupy only a small part of the observation space (Pathak et al., ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2017). Consequently, current state-of-the-art models still accumulate errors too rapidly to be used for look-ahead planning in complex environments. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Another strategy is to train a model such that, when it is used to predict a value function, the error in those predictions is minimised. Doing so can encourage the model to focus on features of the observations that are relevant for the control task. An example is the predictron (Silver et al., 2017b), where the model is used to aid policy evaluation without addressing control. Value prediction networks (VPNs, Oh et al., 2017) take a similar approach but use the model to construct a look-ahead tree only when constructing bootstrap targets and selecting actions, similarly to TD-search (Silver et al., 2012). Crucially, the model is not embedded in a planning algorithm during optimisation. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose a new tree-structured neural network architecture to address the aforementioned problems. By formulating the tree look-ahead in a differentiable way and integrating it directly into the $Q$ - function or policy, we train the entire agent, including its learned transition model, end-to-end. This ensures that the model is optimised for the correct goal and is suitable for on-line planning during execution of the policy. ",
+        "bbox": [
+            174,
+            243,
+            825,
+            313
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since the transition model is only weakly grounded in the actual environment, our approach can alternatively be viewed as a model-free method in which the fully connected layers of DQN are replaced by a recursive network that applies transition functions with shared parameters at each tree node expansion. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            376
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The resulting architecture, which we call TreeQN, encodes an inductive bias based on the prior knowledge that the environment is a stationary Markov process, which facilitates faster learning of better policies. We also present an actor-critic variant, ATreeC, in which the tree is augmented with a softmax layer and used as a policy network. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            439
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We show that TreeQN and ATreeC outperform their DQN-based counterparts in a box-pushing domain and a suite of Atari games, with deeper trees often outperforming shallower trees, and TreeQN outperforming VPN (Oh et al., 2017) on most Atari games. We also present ablation studies investigating various auxiliary losses for grounding the transition model more strongly in the environment, which could improve performance as well as lead to interpretable internal plans. While we show that grounding the reward function is valuable, we conclude that how to learn strongly grounded transition models and generate reliably interpretable plans without compromising performance remains an open research question. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            592,
+            326,
+            608
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We consider an agent learning to act in a Markovimising its expected discounted sum of rewards $\\begin{array} { r } { R _ { t } = \\sum _ { t = 0 } ^ { \\infty } \\gamma ^ { t } r _ { t } } \\end{array}$ s (MDP), with the goa, by learning a policy $\\pi ( \\mathbf { s } )$ max-that maps states to actions . The state-action value function $Q$ -function) is defined as $\\begin{array} { r } { Q ^ { \\pi } ( \\mathbf { s } , a ) = \\mathbb { E } _ { \\pi } \\left[ R _ { t } | \\mathbf { s } _ { t } = \\mathbf { s } , a _ { t } = a \\right] } \\end{array}$ ; the optimal $Q$ -function is $Q ^ { * } ( \\mathbf { s } , a ) = \\operatorname* { m a x } _ { \\pi } Q ^ { \\pi } ( \\mathbf { s } , a )$ . ",
+        "bbox": [
+            174,
+            632,
+            825,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The Bellman optimality equation writes $Q ^ { * }$ recursively as ",
+        "bbox": [
+            174,
+            695,
+            553,
+            710
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f0325e8db1192dd6201596cb4422597d173141d7c85562bc1cc2675910818cf7.jpg",
+        "text": "$$\nQ ^ { * } ( \\mathbf { s } , a ) = T Q ^ { * } ( \\mathbf { s } , a ) \\equiv r ( \\mathbf { s } , a ) + \\gamma \\sum _ { \\mathbf { s ^ { \\prime } } } P ( \\mathbf { s } ^ { \\prime } | \\mathbf { s } , a ) \\operatorname* { m a x } _ { a ^ { \\prime } } Q ^ { * } ( \\mathbf { s } ^ { \\prime } , a ^ { \\prime } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            276,
+            731,
+            720,
+            763
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $P$ is the MDP state transition function and $r$ is a reward function, which for simplicity we assume to be deterministic. $Q$ -learning (Watkins $\\&$ Dayan, 1992) uses a single-sample approximation of the contraction operator $\\tau$ to iteratively improve an estimate of $Q ^ { * }$ . ",
+        "bbox": [
+            174,
+            784,
+            825,
+            827
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In deep $Q$ -learning (Mnih et al., 2015), $Q$ is represented by a deep neural network with parameters $\\theta$ , and is improved by regressing $Q ( \\mathbf { s } , a )$ to a target $r + \\bar { \\gamma } \\operatorname* { m a x } _ { a ^ { \\prime } } Q ( \\mathbf { s } ^ { \\prime } , a ^ { \\prime } ; \\theta ^ { - } )$ , where $\\theta ^ { - }$ are the parameters of a target network periodically copied from $\\theta$ . ",
+        "bbox": [
+            174,
+            832,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use a version of $n$ -step $Q$ -learning (Mnih et al., 2016) with synchronous environment threads. In particular, starting at a timestep $t$ , we roll forward $n _ { \\mathrm { e n v } } = 1 6$ threads for $n = 5$ timesteps each. We then bootstrap off the final states only and gather all $n _ { \\mathrm { e n v } } \\times n = 8 0$ transitions in a single batch for ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "the backward pass, minimising the loss: ",
+        "bbox": [
+            174,
+            103,
+            436,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb4fe8eae95faef35b8d32e21ad413f41a947335fbd30d9afcfdb492e52878de.jpg",
+        "text": "$$\n\\mathcal { L } _ { \\mathrm { n s t e p . Q } } = \\sum _ { \\mathrm { e n v s } } \\sum _ { j = 1 } ^ { n } \\left( \\sum _ { k = 1 } ^ { j } \\left[ \\gamma ^ { j - k } r _ { t + n - k } \\right] + \\gamma ^ { j } \\operatorname* { m a x } _ { a ^ { \\prime } } Q \\left( \\mathbf { s } _ { t + n } , a ^ { \\prime } , \\theta ^ { - } \\right) - Q \\left( \\mathbf { s } _ { t + n - j } , a _ { t + n - j } , \\theta \\right) \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            122,
+            818,
+            170
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If the episode terminates, we use the remaining episode return as the target, without bootstrapping. ",
+        "bbox": [
+            174,
+            180,
+            820,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This algorithm’s actor-critic counterpart is A2C, a synchronous variant of A3C (Mnih et al., 2016) in which a policy $\\pi$ and state-value function $V ( s )$ are trained using the gradient: ",
+        "bbox": [
+            173,
+            202,
+            825,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c120c1ff46dc5e6c8e6fa8d0a5c89be14191aa3a3273e48447fb78ca5074f944.jpg",
+        "text": "$$\n\\Delta \\theta = \\sum _ { \\mathrm { e n v s } } \\sum _ { j = 1 } ^ { n } \\nabla _ { \\theta _ { \\tau } } \\log \\pi ( a _ { t + n - j } | s _ { t + n - j } ) A _ { j } ( s _ { t + n - j } , a _ { t + n - j } ) + \\beta \\nabla _ { \\theta _ { \\tau } } H ( \\pi ( s _ { t + n - j } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            189,
+            236,
+            763,
+            279
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/88d945befa96c109b91c575e4ff7b3015918194da7a50939bdf6db8d9cf667d2.jpg",
+        "text": "$$\n+ \\alpha \\nabla _ { \\theta _ { V } } A _ { j } ( s _ { t + n - j } , a _ { t + n - j } ) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            578,
+            281,
+            787,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $A _ { j }$ is an advantage estimate given by $\\begin{array} { r } { \\sum _ { k = 1 } ^ { j } \\gamma ^ { j - k } r _ { t + n - k } + \\gamma ^ { j } V ( \\mathbf { s } _ { t + n } ) - V ( \\mathbf { s } _ { t + n - j } ) , . } \\end{array}$ $H$ is the policy entropy, $\\beta$ is a hyperparameter tuning the degree of entropy regularisation, and $\\alpha$ is a hyperparameter controlling the relative learning rates of actor and critic. ",
+        "bbox": [
+            176,
+            304,
+            823,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "These algorithms were chosen for their simplicity and reasonable wallclock speeds, but TreeQN can also be used in other algorithms, as described in Section 3. Our implementations are based on OpenAI Baselines (Hesse et al., 2017). ",
+        "bbox": [
+            176,
+            354,
+            823,
+            397
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The canonical neural network architecture in deep RL with visual observations has a series of convolutional layers followed by two fully connected layers, where the final layer produces one output for each action-value. We can think of this network as first calculating an encoding $\\mathbf { z } _ { t }$ of the state $\\mathbf { s } _ { t }$ which is then evaluated by the final layer to estimate $Q ^ { * } ( \\mathbf { s } _ { t } , a )$ (see Fig. 1). ",
+        "bbox": [
+            174,
+            404,
+            576,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a1c8aa777b391aa8e4813f2342fedb38e83445bf81cda679495660e595151def.jpg",
+        "image_caption": [
+            "Figure 1: High-level structure of DQN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            604,
+            417,
+            808,
+            494
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In tree-search on-line planning, a look-ahead tree of possible future states is constructed by recursively applying an environment model. These states are typically evaluated by a heuristic, a learned value function, or Monte-Carlo rollouts. Backups through the tree aggregate these values along with the immediate rewards accumulated along each path to estimate the value of taking an action in the current state. This paper focuses on a simple tree-search with a deterministic transition function and no value uncertainty estimates, but our approach can be extended to tree-search variants like UCT (Kocsis & Szepesvari´ , 2006; Silver et al., 2016) if the components remain differentiable. ",
+        "bbox": [
+            173,
+            494,
+            576,
+            536
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            536,
+            825,
+            606
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 TREEQN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            625,
+            281,
+            642
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we propose TreeQN, a novel end-to-end differentiable tree-structured architecture for deep reinforcement learning. We first give an overview of the architecture, followed by details of each model component and the training procedure. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "TreeQN uses a recursive tree-structured neural network between the encoded state $\\mathbf { z } _ { t }$ and the predicted state-action values $Q ( \\mathbf { s } _ { t } , a )$ , instead of directly estimating the state-action value from the current encoded state $\\mathbf { z } _ { t }$ using fully connected layers as in DQN (Mnih et al., 2015). Specifically, TreeQN uses a recursive model to refine its estimate of $Q ( \\mathbf { s } _ { t } , a )$ via learned transition, reward, and value functions, and a tree backup (see Fig. 2). Because these learned components are shared throughout the tree, TreeQN implements an inductive bias, missing from DQN, that reflects the prior knowledge that the $Q$ -values are properties of a stationary Markov process. We also encode the inductive bias that $Q$ -values may be expressed as a sum of scalar rewards and values. ",
+        "bbox": [
+            173,
+            705,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { z } _ { l \\mid t }$ cifically, TreeQN learns an action-de, predicts the next state representation $\\mathbf { z } _ { l + 1 | t } ^ { a _ { i } }$ t transitiofor action $a _ { i } \\in { \\mathcal { A } }$ n that, given a state representa, and the corresponding reward $\\hat { r } _ { l | t } ^ { a _ { i } }$ To make the distinction between internal planning steps and steps taken in the environment explicit, we write $\\mathbf { z } _ { l \\mid t }$ to denote the encoded state at time $t$ after $l$ internal transitions, starting with ${ \\bf z } _ { 0 \\mid t }$ for the encoding of $\\mathbf { s } _ { t }$ . TreeQN applies this transition function recursively to construct a tree containing the state representations and rewards received for all possible sequences of actions up to some predefined depth $d$ (“Tree Transitioning” in Fig. 2). ",
+        "bbox": [
+            173,
+            823,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e166e58c3a5bca1ad7d1969b9d7a51bd50882c1420e24550565fb81a4f0a5e82.jpg",
+        "image_caption": [
+            "Figure 2: High-level structure of TreeQN with a tree depth of two and shared transition and evaluation functions (reward prediction and value mixing omitted for simplicity). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            98,
+            792,
+            393
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The value of each predicted state $V ( \\mathbf { z } )$ is estimated with a value function module. Using these values and the predicted rewards, TreeQN then performs a tree backup, mixing the $k$ -step returns along each path in the tree using $\\mathrm { T D } ( \\lambda )$ (Sutton, 1988; Sutton & Barto, 1998). This corresponds to “Value Prediction & Backup” in Fig. 2 and can be formalized as ",
+        "bbox": [
+            174,
+            458,
+            825,
+            515
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1a7e940d2c3897a727fa0dfe9800605bfaf952fcd3e922fa620bede71e4badf.jpg",
+        "text": "$$\n\\begin{array} { r l } & { Q ^ { l } ( \\mathbf { z } _ { l \\mid t } , a _ { i } ) = r ( \\mathbf { z } _ { l \\mid t } , a _ { i } ) + \\gamma V ^ { ( \\lambda ) } ( \\mathbf { z } _ { l + 1 \\mid t } ) } \\\\ & { V ^ { ( \\lambda ) } ( \\mathbf { z } _ { l \\mid t } ) = \\left\\{ V ( \\mathbf { z } _ { l \\mid t } ^ { a _ { i } } ) \\right. \\ } & { l = d } \\\\ & { \\left. ( 1 - \\lambda ) V ( \\mathbf { z } _ { l \\mid t } ^ { a _ { i } } ) + \\lambda \\mathrm { b } ( Q ^ { l + 1 } ( \\mathbf { z } _ { l + 1 \\mid t } ^ { a _ { i } } , a _ { j } ) ) \\right. \\ l < d } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            284,
+            521,
+            715,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathrm { b }$ is a function to recursively perform the backup. For $0 < \\lambda < 1$ , value estimates of the intermediate states are mixed into the final $Q$ -estimate, which encourages the intermediate nodes of the tree to correspond to meaningful states, and reduces the impact of outlier values. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            637
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When $\\lambda = 1$ , and $\\mathrm { b }$ is the standard hard max function, then Eq. 3 simplifies to a backup through the tree using the familiar Bellman equation: ",
+        "bbox": [
+            171,
+            642,
+            823,
+            671
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5af72a52b71e0a2003db1334e62e824a5cf92651056c2f02750a0961ddf1191d.jpg",
+        "text": "$$\nQ ( \\mathbf { z } _ { l | t } , a _ { i } ) = r ( \\mathbf { z } _ { l | t } , a _ { i } ) + \\left\\{ \\begin{array} { l l } { \\gamma V ( \\mathbf { z } _ { d | t } ^ { a _ { i } } ) } & { l = d - 1 } \\\\ { \\gamma \\operatorname* { m a x } _ { a _ { j } } Q ( \\mathbf { z } _ { l + 1 | t } ^ { a _ { i } } , a _ { j } ) } & { l < d - 1 . } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            679,
+            710,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We note that even for a tree depth of only one, TreeQN imposes a significant structure on the value function by decomposing it as a sum of action-conditional reward and next-state value, and using a shared value function to evaluate each next-state representation. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Crucially, during training we backpropagate all the way from the final $Q$ -estimate, through the value prediction, tree transitioning, and encoding layers of the tree, i.e., the entire network shown in Fig. 2. Learning these components jointly ensures that they are useful for planning on-line. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            829
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 MODEL COMPONENTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            847,
+            370,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe each of TreeQN’s components in more detail. ",
+        "bbox": [
+            173,
+            873,
+            653,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Encoder function. As in DQN, a series of convolutional layers produces an embedding of the observed state, $\\mathbf { z } _ { 0 \\mid t } = \\mathsf { e n c o d e } ( \\mathbf { s } _ { t } )$ . ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transition function. We first apply a single fully connected layer to the current state embedding, shared by all actions. This generates an intermediate representation $( \\mathbf z _ { l + 1 | t } ^ { \\mathrm { e n v } } )$ that could carry information about action-agnostic changes to the environment. In addition, we use a fully connected layer per action, which is applied to the intermediate representation to calculate a next-state representation that carries information about the effect of taking action $a _ { i }$ . We use residual connections for these layers: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1cc56226dca3fd2c74e9e3e263dce01cc30a270adb40a317f460914e1a6070f9.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { z } _ { l + 1 \\mid t } ^ { \\mathrm { e n v } } = \\mathbf { z } _ { l \\mid t } + \\operatorname { t a n h } ( W ^ { \\mathrm { e n v } } \\mathbf { z } _ { l \\mid t } + \\mathbf { b } ^ { \\mathrm { e n v } } ) , } \\\\ & { \\mathbf { z } _ { l + 1 \\mid t } ^ { a _ { i } } = \\mathbf { z } _ { l + 1 \\mid t } ^ { \\mathrm { e n v } } + \\operatorname { t a n h } ( W ^ { a _ { i } } \\mathbf { z } _ { l + 1 \\mid t } ^ { \\mathrm { e n v } } ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            181,
+            629,
+            224
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W ^ { a _ { i } } , W ^ { \\mathrm { e n v } } \\in \\mathbb R ^ { k \\times k } , \\mathbf { b } ^ { \\mathrm { e n v } } \\in \\mathbb R ^ { k }$ are learnable parameters. Note that the next-state representation is calculated for every action $a _ { i }$ independently using the respective transition matrix $W ^ { a _ { i } }$ , but this transition function is shared for the same action throughout the tree. ",
+        "bbox": [
+            174,
+            228,
+            825,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A caveat is that the model can still learn to use different parts of the latent state space in different parts of the tree, which could undermine the intended parameter sharing in the model structure. To help TreeQN learn useful transition functions that maintain quality and diversity in their latent states, we introduce a unit-length projection of the state representations by simply dividing a state’s vector representation by its L2 norm before each application of the transition function, $\\mathbf { z } _ { l | t } : = \\mathbf { z } _ { l | t } / \\left| \\left| \\mathbf { z } _ { l | t } \\right| \\right|$ This prevents the magnitude of the representation from growing or shrinking, which encourages the behaviour of the transition function to be more consistent throughout the tree. ",
+        "bbox": [
+            173,
+            277,
+            825,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reward function. In addition to predicting the next state, we also predict the immediate reward for every action $a _ { i } \\in { \\mathcal { A } }$ in state $\\mathbf { z } _ { l \\mid t }$ using ",
+        "bbox": [
+            174,
+            382,
+            821,
+            411
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d17ef4c2d86919d0fb624edbb517804f5b93c41fc71b74c246b652b5fa77f495.jpg",
+        "text": "$$\n\\hat { \\mathbf { r } } ( \\mathbf { z } _ { l \\mid t } ) = W _ { 2 } ^ { r } \\mathrm { R e L U } ( W _ { 1 } ^ { r } \\mathbf { z } _ { l \\mid t } + \\mathbf { b } _ { 1 } ^ { r } ) + \\mathbf { b } _ { 2 } ^ { r } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            419,
+            637,
+            438
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { 1 } ^ { r } \\in \\mathbb { R } ^ { m \\times k }$ , $W _ { 2 } ^ { r } \\in \\mathbb { R } ^ { | \\mathcal { A } | \\times m }$ and ReLU is the rectified linear unit (Nair & Hinton, 2010), and the predicted reward for a particular action $\\hat { r } _ { l | t } ^ { a _ { i } }$ is the $i$ -th element of the vector $\\hat { \\mathbf { r } } ( \\mathbf { z } _ { l \\mid t } )$ . ",
+        "bbox": [
+            176,
+            443,
+            825,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Value function. The value of a state representation $\\mathbf { z }$ is estimated as ",
+        "bbox": [
+            174,
+            482,
+            622,
+            497
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/24d866580076ae34f26d604f1667a9e9c5077c010694fcd6e973310df20d538c.jpg",
+        "text": "$$\nV ( \\mathbf { z } ) = \\mathbf { w } ^ { \\top } \\mathbf { z } + b ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            502,
+            560,
+            521
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { w } \\in \\mathbb { R } ^ { k }$ ",
+        "bbox": [
+            174,
+            529,
+            276,
+            542
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Backup function. We use the following function that can be recursively applied to calculate the tree backup: ",
+        "bbox": [
+            173,
+            550,
+            825,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5375297e5372a93344aa95adc3a94f5401317bf8a2952c1c9636c483110a219e.jpg",
+        "text": "$$\n\\mathrm { b } ( \\mathbf { x } ) = \\sum _ { i } x _ { i } \\mathrm { s o f t m a x } ( \\mathbf { x } ) _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            584,
+            594,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using a hard max for calculating the backup would result in gradient information only being used to update parameters along the maximal path in the tree. By contrast, the softmax allows us to use downstream gradient information to update parameters along all paths. Furthermore, it potentially reduces the impact of outlier value predictions. With a learned temperature for the softmax, this function could represent the hard max arbitrarily closely. However, we did not find an empirical difference so we left the temperature at 1. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 GROUNDING THE MODEL COMPONENTS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            488,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The TreeQN architecture is fully differentiable, so we can directly use it in the place of a $Q$ -function in any deep RL algorithm with discrete actions. Differentiating through the entire tree ensures that the learned components are useful for planning on-line, as long as that planning is performed in the same way as during training. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            806
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "However, it seems plausible that auxiliary objectives based on minimising the error in predicting rewards or observations could improve the performance by helping to ground the transition and reward functions to the environment. It could also encourage TreeQN to perform model-based planning in an interpretable manner. In principle, such objectives could give rise to a spectrum of methods from model-free to fully model-based. At one extreme, TreeQN without auxiliary objectives can be seen as a model-free approach that draws inspiration from tree-search planning to encode valuable inductive biases into the neural network architecture. At the other extreme, perfect, grounded reward and transition models could in principle be learned. Using them in our architecture would then correspond to standard model-based lookahead planning. The sweet spot could be an intermediate level of grounding that maintains the flexibility of end-to-end model-free learning while benefiting from the additional supervision of explicit model learning. To investigate this spectrum, we experiment with two auxiliary objectives. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Reward grounding. We experiment with an L2 loss regressing rˆat:t+l−1| , the predicted reward at level $l$ of the tree corresponding to the selected action sequence $\\left\\{ a _ { t } \\ldots a _ { t + l - 1 } \\right\\}$ , to the true observed rewards. For each of the $n$ timesteps of $n$ -step Q-learning this gives: ",
+        "bbox": [
+            174,
+            165,
+            825,
+            213
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e35f4ada56ea365bf7935959899e01fb826572b58d596c6ddb305b66cbc9cff.jpg",
+        "text": "$$\n\\mathcal { L } = \\mathcal { L } _ { \\mathrm { n s t e p } \\cdot \\mathrm { Q } } + \\eta _ { r } \\sum _ { \\mathrm { e n v s } } \\sum _ { j = 1 } ^ { n } \\sum _ { l = 1 } ^ { \\bar { d } } \\left( \\hat { r } _ { l \\mid t + j } ^ { a _ { t + j : t + j + l - 1 } } - r _ { t + j + l - 1 } \\right) ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            219,
+            697,
+            265
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta _ { r }$ is a hyperparameter weighting the loss, and $\\bar { d } = \\operatorname* { m i n } ( d , n - j + 1 )$ restricts the sum to rewards for which we have already observed the true value. ",
+        "bbox": [
+            173,
+            273,
+            825,
+            303
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "State grounding. We experiment with a grounding in the latent space, using an L2 loss to regress the predicted latent state $\\mathbf { z } _ { l \\mid t } ^ { a _ { t : t + l } }$ at level $l$ of the tree to $\\mathbf { z } _ { 0 \\mid t + l }$ , the initial encoding of the true state corresponding to the actions actually taken: ",
+        "bbox": [
+            174,
+            309,
+            825,
+            354
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8252bdd7d3e5bed7dff7ea41d218882400e1f1b9433929b4c06e741ca7f67ad.jpg",
+        "text": "$$\n\\mathcal { L } = \\mathcal { L } _ { \\mathrm { n s t e p } \\cdot \\mathrm { Q } } + \\eta _ { s } \\sum _ { \\mathrm { e n v s } } \\sum _ { j = 1 } ^ { n } \\sum _ { l = 1 } ^ { \\bar { d } } \\left( \\mathbf { z } _ { l \\mid t + j } ^ { a _ { t + j : t + j + l - 1 } } - \\mathbf { z } _ { 0 \\mid t + j + l } \\right) ^ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            361,
+            696,
+            407
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "By employing an additional decoder module, we could use a similar loss to regress decoded observations to the true observations. In informal experiments, joint training with such a decoder loss did not yield good performance, as also found by Oh et al. (2017). ",
+        "bbox": [
+            174,
+            414,
+            825,
+            457
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Section 7.1, we present results on the use these objectives, showing that reward grounding gives better performance, but that our method for state grounding does not. ",
+        "bbox": [
+            173,
+            462,
+            825,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 ATREEC ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            279,
+            527
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The intuitions guiding the design of TreeQN are as applicable to policy search as to valuebased RL, in that a policy can use a tree planner to improve its estimates of the optimal action probabilities (Gelly & Silver, 2007; Silver et al., 2017a). As our proposed architecture is trained end-to-end, it can be easily adapted for use as a policy network. ",
+        "bbox": [
+            174,
+            544,
+            485,
+            656
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In particular, we propose ATreeC, an actor-critic extension of TreeQN. In this architecture, the policy network is identical to TreeQN, with an additional softmax layer that converts the $Q$ estimates into the probabilities of a stochastic policy. ",
+        "bbox": [
+            173,
+            662,
+            485,
+            732
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/c25055870dfdd057fb07bebcc4851a33c1d3f8f989097e46a5424ba4be71f1b0.jpg",
+        "image_caption": [
+            "Figure 3: High-level structure of ATreeC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            504,
+            553,
+            823,
+            693
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The critic shares the encoder parameters, and predicts a scalar state value with a single fully connected layer: $V _ { \\mathrm { c r } } ( \\mathbf { s } ) = \\mathbf { w } _ { \\mathrm { c r } } ^ { \\top } \\mathbf { z } + b _ { \\mathrm { c r } }$ . We used different parameters for the critic value function and the actor’s tree-value-function module, but found that sharing these parameters had little effect on performance. The entire setup, shown in Fig. 3, is trained with A2C as described in Section 2, with the addition of the same auxiliary losses used for TreeQN. Note that TreeQN could also be used in the critic, but we leave this possibility to future work. ",
+        "bbox": [
+            174,
+            732,
+            826,
+            815
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            344,
+            852
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "There is a long history of work combining model-based and model-free RL. An early example is Dyna-Q (Sutton, 1990) which trains a model-free algorithm with samples drawn from a learned model. Similarly, van Seijen et al. (2011) train a sparse model with some environment samples that can be used to refine a model-free $Q$ -function. Gu et al. (2016) use local linear models to generate additional samples for their model-free algorithm. However, these approaches do not attempt to use the model on-line to improve value estimates. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In deep RL, value iteration networks (Tamar et al., 2016) use a learned differentiable model to plan on the fly, but require planning over the full state space, which must also possess a spatial structure with local dynamics such that convolution operations can execute the planning algorithm. ",
+        "bbox": [
+            176,
+            138,
+            821,
+            180
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The predictron (Silver et al., 2017b) instead learns abstract-state transition functions in order to predict values. However, it is restricted to policy evaluation without control. Value prediction networks (VPNs, Oh et al., 2017) take a similar approach but are more closely related to our work because the learned model components are used in a tree for planning. However, in their work this tree is only used to construct targets and choose actions, and not to compute the value estimates during training. Such estimates are instead produced from non-branching trajectories following on-policy action sequences. By contrast, TreeQN is a unified architecture that constructs the tree dynamically at every timestep and differentiates through it, eliminating any mismatch between the model at training and test time. Furthermore, we do not use convolutional transition functions, and hence do not impose spatial structure on the latent state representations. These differences simplify training, allow our model to be used more flexibly in other training regimes, and explain in part our substantially improved performance on the Atari benchmark. ",
+        "bbox": [
+            174,
+            188,
+            825,
+            354
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Donti et al. (2017) propose differentiating through a stochastic programming optimisation using a probabilistic model to learn model parameters with respect to their true objective rather than a maximum likelihood surrogate. However, they do not tackle the full RL setting, and do not use the model to repeatedly or recursively refine predictions. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            417
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Imagination-augmented agents (Weber et al., 2017) learn to improve policies by aggregating rollouts predicted by a model. However, they rely on pretraining an observation-space model, which we argue will scale poorly to more complex environments. Further, their aggregation of rollout trajectories takes the form of a generic RNN rather than a value function and tree backup, so the inductive bias based on the structure of the MDP is not explicitly present. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            494
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A class of value gradient methods (Deisenroth & Rasmussen, 2011; Fairbank & Alonso, 2012; Heess et al., 2015) also differentiates through models to train a policy. However, this approach does not use the model during execution to refine the policy, and requires continuous action spaces. ",
+        "bbox": [
+            176,
+            501,
+            820,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Oh et al. (2015) and Chiappa et al. (2017) propose methods for learning observation-prediction models in the Atari domain, but use these models only to improve exploration. Variants of scheduled sampling (Bengio et al., 2015) may be used to improve robustness of these models, but scaling to complex domains has proven challenging (Talvitie, 2014). ",
+        "bbox": [
+            174,
+            549,
+            825,
+            606
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            627,
+            326,
+            642
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We evaluate TreeQN and ATreeC in a simple box-pushing environment, as well as on the subset of nine Atari environments that Oh et al. (2017) use to evaluate VPN. The experiments are designed to determine whether or not TreeQN and ATreeC outperform DQN, A2C, and VPN, and whether they can scale to complex domains. We also investigate how to best ground the the transition function with auxiliary losses. Furthermore, we compare against alternative ways to increase the number of parameters and computations of a standard DQN architecture, and study the impact of tree depth. Full details of the experimental setup, as well as architecture and training hyperparameters, are given in the appendix. ",
+        "bbox": [
+            173,
+            659,
+            825,
+            770
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Grounding. We perform a hyperparameter search over the coefficients $\\eta _ { r }$ and $\\eta _ { s }$ of the reward and state grounding auxiliary losses, on the Atari environment Seaquest. These experiments aim to determine the relevant trade-offs between the flexibility of a model-free approach and the potential benefits of a more model-based algorithm. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Box Pushing. We randomly place an agent, 12 boxes, 5 goals and 6 obstacles on the center $6 \\times 6$ tiles of an $8 \\times 8$ grid. The agent’s goal is to push boxes into goals in as few steps as possible while avoiding obstacles. Boxes may not be pushed into each other. The obstacles, however, are ‘soft’ in that they are do not block movement, but generate a negative reward if the agent or a box moves onto an obstacle. This rewards better planning without causing excessive gridlock. This environment is inspired by Sokoban, as used by Weber et al. (2017), in that poor actions can generate irreversibly bad configurations. However, the level generation process for Sokoban is challenging to reproduce exactly and has not been open-sourced. More details of the environment and rewards are given in Appendix A.1. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/97da6ea8c2b8e8eaa44c239e1def910645c5c0d4ba1ee593d6f68ab36d648d3a.jpg",
+        "image_caption": [
+            "Figure 4: Grounding the reward and transition functions using auxiliary losses: final returns on Seaquest plotted against the coefficient of the auxiliary loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            102,
+            794,
+            301
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            367,
+            823,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Atari. To demonstrate the general applicability of TreeQN and ATreeC to complex environments, we evaluate them on the Atari 2600 suite (Bellemare et al., 2013). Following Oh et al. (2017), we use their set of nine environments and a frameskip of 10 to facilitate planning over reasonable timescales. ",
+        "bbox": [
+            174,
+            416,
+            823,
+            459
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "TreeQN adds additional parameters to a standard DQN architecture. We compare TreeQN to two baseline architectures with increased computation and numbers of parameters to verify the benefit of the additional structure and grounding. DQN-Wide doubles the size of the embedding dimension (1024 instead of 512). DQN-Deep inserts two additional fully connected layers with shared parameters and residual connections between the two fully-connected layers of DQN. This is in effect a non-branching version of the TreeQN architecture that also lacks explicit reward prediction. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            549
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 RESULTS & DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            411,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present our experimental results for TreeQN and ATreeC. ",
+        "bbox": [
+            174,
+            603,
+            671,
+            618
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.1 GROUNDING",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            302,
+            650
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 shows the result of a hyperparameter search on $\\eta _ { r }$ and $\\eta _ { s }$ , the coefficients of the auxiliary losses on the predicted rewards and latent states. An intermediate value of $\\eta _ { r }$ helps performance but there is no benefit to using the latent space loss. Subsequent experiments use $\\eta _ { r } = 1$ and $\\eta _ { s } = 0$ . ",
+        "bbox": [
+            174,
+            662,
+            823,
+            704
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The predicted rewards that the reward-grounding objective encourages the model to learn appear both in its own $Q$ -value prediction and in the target for $n$ -step $Q$ -learning. Consequently, we expect this auxiliary loss to be well aligned with the true objective. By contrast, the state-grounding loss (and other potential auxiliary losses) might help representation learning but would not explicitly learn any part of the desired target. It is possible that this mismatch between the auxiliary and primary objective leads to degraded performance when using this form of state grounding. One potential route to overcoming this obstacle to joint training would be pre-training a model, as done by Weber et al. (2017). Inside TreeQN this model could then be fine-tuned to perform well inside the planner. We leave this possiblity to future work. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            837
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.2 BOX PUSHING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            313,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5a shows the results of TreeQN with tree depths 1, 2, and 3, compared to a DQN baseline. In this domain, there is a clear advantage for the TreeQN architecture over DQN. TreeQN learns policies that are substantially better at avoiding obstacles and lining boxes up with goals so they can be easily pushed in later. TreeQN also substantially speeds up learning. We believe that the greater structure brought by our architecture regularises the model, encouraging appropriate state representations to be learned quickly. Even a depth-1 tree improves performance significantly, as disentangling the estimation of rewards and next-state values makes them easier to learn. This is further facilitated by the sharing of value-function parameters across branches. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbb23d8d559767eabf733b8c2ecddefc93e437f2c2583281060880ce9d7b044a.jpg",
+        "image_caption": [
+            "Figure 5: Box-pushing results: the $x$ -axis shows the number of transitions observed across all of the synchronous environment threads. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            103,
+            794,
+            285
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            349,
+            825,
+            420
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "When trained with $n$ -step Q-learning, the deeper depth-2 and depth-3 trees learn faster and plateau higher than the shallow depth-1 tree. In the this domain, useful transition functions are relatively easy to learn, and the extra computation time with those transition modules can help refine value estimates, yielding advantages for additional depth. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            483
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fig. 5b shows the results of ATreeC with tree depths 1, 2, and 3, compared to an A2C baseline. As with TreeQN, ATreeC substantially outperforms the baseline. Furthermore, thanks to its stochastic policy, it substantially outperforms TreeQN. Whereas TreeQN and DQN sometimes indecisively bounce back and forth between adjacent states, ATreeC captures this uncertainty in its policy probabilities and thus acts more decisively. However, unlike TreeQN, ATreeC shows no pronounced differences for different tree depths. This is in part due to a ceiling effect in this domain. However, ATreeC is also gated by the quality of the critic’s value function, which in these experiments was a single linear layer after the state encoding as described in Section 4. Nonetheless, this result demonstrates the ease with which TreeQN can be used as a drop-in replacement for any deep RL algorithm that learns policies or value functions for discrete actions. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.3 ATARI ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            258,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarises all our Atari results, while Fig. 6 shows learning curves in depth. TreeQN shows substantial benefits in many environments compared to our DQN baseline, which itself often outperforms VPN (Oh et al., 2017). ATreeC always matches or outperforms A2C. We present the mean performance of five random seeds, while the VPN results reported by Oh et al. (2017), shown as dashed lines in Fig. 6, are the mean of the best five seeds of an unspecified number of trials. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            742
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "TreeQN. In all environments except Frostbite, TreeQN outperforms DQN on average, with the most significant gains in Alien, CrazyClimber, Enduro, Krull, and Seaquest. Many of these environments seem well suited to short horizon look-ahead planning, with simple dynamics that generalise well and tradeoffs between actions that become apparent only after several timesteps. For example, an incorrect action in Alien can trap the agent down a corridor with an alien. In Seaquest, looking ahead could help determine whether it is better to go deeper to collect more points or to surface for oxygen. However, even in a game with mostly reactive decisions like the racing game Enduro, TreeQN shows significant benefits. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "TreeQN also outperforms the additional baselines of DQN-Wide and DQN-Deep, indicating that the additional structure and grounding of our architecture brings benefits beyond simply adding model capacity and computation. In particular, it is interesting that DQN-Deep is often outperformed by the vanilla DQN baseline, as optimisation difficulties grow with depth. In contrast, the additional structure and auxiliary loss employed by TreeQN turn its additional depth from a liability into a strength. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/8a8b0162732a2a7f45e78c6ce7220ef0c080f2a73238d623627d2ab9ddf1a446.jpg",
+        "image_caption": [
+            "Figure 6: Results for the Atari domain. The y-axis shows the moving average over 100 episodes. Each of five random seeds is plotted faintly, with the mean in bold. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            813,
+            897
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/ccf7558c76007770d4c8c57c9209fe12aa2e1548dce9149da409f75499bdf920.jpg",
+        "table_caption": [
+            "Table 1: Summary of Atari results. Each number is the best score throughout training, calculated as the mean of the last 100 episode rewards averaged over exactly five agents trained with different random seeds. Note that Oh et al. (2017) report the same statistic, but average instead over the best five of an unspecified number of agents. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Alien</td><td>Amidar</td><td>Crazy Climber</td><td>Enduro</td><td>Frostbite</td><td>Krull</td><td>Ms.Pacman</td><td>Q*Bert</td><td>Seaquest</td></tr><tr><td>DQN (Oh et al., 2017)</td><td>1804</td><td>535</td><td>41658</td><td>326</td><td>3058</td><td>12438</td><td>2804</td><td>12592</td><td>2951</td></tr><tr><td>VPN (Oh et al.,2017)</td><td>1429</td><td>641</td><td>54119</td><td>382</td><td>3811</td><td>15930</td><td>2689</td><td>14517</td><td>5628</td></tr><tr><td>n-step DQN</td><td>1969</td><td>1033</td><td>71623</td><td>625</td><td>3968</td><td>7860</td><td>2774</td><td>14468</td><td>3465</td></tr><tr><td>DQN-Deep</td><td>1906</td><td>825</td><td>53101</td><td>745</td><td>493</td><td>8605</td><td>2410</td><td>15094</td><td>3575</td></tr><tr><td>DQN-Wide</td><td>2187</td><td>1074</td><td>91380</td><td>682</td><td>3493</td><td>6603</td><td>3061</td><td>15794</td><td>3909</td></tr><tr><td>TreeQN-1</td><td>2321</td><td>1030</td><td>107983</td><td>800</td><td>2254</td><td>10836</td><td>3030</td><td>15688</td><td>9302</td></tr><tr><td>TreeQN-2</td><td>2497</td><td>1170</td><td>104932</td><td>825</td><td>581</td><td>11035</td><td>3277</td><td>15970</td><td>8241</td></tr><tr><td>A2C</td><td>2673</td><td>1525</td><td>102776</td><td>642</td><td>297</td><td>5784</td><td>4352</td><td>24451</td><td>1734</td></tr><tr><td>ATreeC-1</td><td>3448</td><td>1578</td><td>102546</td><td>678</td><td>1035</td><td>8227</td><td>4866</td><td>25159</td><td>1734</td></tr><tr><td>ATreeC-2</td><td>2813</td><td>1566</td><td>110712</td><td>649</td><td>281</td><td>8134</td><td>4450</td><td>25459</td><td>2176</td></tr></table>",
+        "bbox": [
+            176,
+            101,
+            821,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            325,
+            823,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ATreeC. ATreeC matches or outperforms its baseline (A2C) in all environments. Compared to TreeQN, ATreeC’s performance is better across most environments, particularly on Qbert, reflecting an overall advantage for actor-critic also found by Mnih et al. (2016) and in our box-pushing experiments. However, performance is much worse on Seaquest, revealing a deficiency in exploration as policy entropy collapses too rapidly and consequently the propensity of policy gradient methods to become trapped in a local optimum. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            445
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In Krull and Frostbite, most algorithms have poor performance, or high variance in returns from run to run, as agents are gated by their ability to explore. Both of these games require the completion of sub-levels in order to accumulate large scores, and none of our agents reliably explore beyond the initial stages of the game. Mean performance appears to favor TreeQN and ATreeC in Krull, and perhaps DQN in Frostbite, but the returns are too variable to draw conclusions from this number of random seeds. Combining TreeQN and ATreeC with smart exploration mechanisms is an interesting direction for future work to improve robustness of training in these types of environments. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            550
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Compared to the box-pushing domain, there is less of a clear performance difference between trees of different depths. In some environments (Amidar, MsPacman), greater depth does appear to be employed usefully by TreeQN to a small extent, resulting in the best-performing individual agents. However, for the Atari domain the embedding size for the transition function we use is much larger (512 compared to 128), and the dynamics are much more complex. Consequently, we expect that optimisation difficulties, and the challenge of learning abstract-state transition functions, impede the utility of deeper trees in some cases. We look to future work to further refine methods for learning to plan abstractly in complex domains. However, the decomposition of Q-value into reward and next-state value employed by the first tree expansion is clearly of utility in a broad range of tasks. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            683
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "When inspecting the learned policies and trees, we find that the values sometimes correspond to intuitive reasoning about sensible policies, scoring superior action sequences above poorer ones. However, we find that the actions corresponding to branches of the tree that are scored most highly are frequently not taken in future timesteps. The flexibility of TreeQN and ATreeC allows our agents to find any useful way to exploit the computation in the tree to refine action-value estimates. As we found no effective way to strongly ground the model components without sacrificing performance, the interpretability of learned trees is limited. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            786
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSIONS & FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            482,
+            824
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "We presented TreeQN and ATreeC, new architectures for deep reinforcement learning in discreteaction domains that integrate differentiable on-line tree planning into the action-value function or policy. Experiments on a box-pushing domain and a set of Atari games show the benefit of these architectures over their counterparts, as well as over VPN. In future work, we intend to investigate enabling more efficient optimisation of deeper trees, encouraging the transition functions to produce interpretable plans, and integrating smart exploration. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We thank Sasha Salter, Luisa Zintgraf, and Wendelin Bohmer for their contributions and valuable ¨ comments on drafts of this paper. This work was supported by the UK EPSRC CDT in Autonomous Intelligent Machines and Systems. This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement #637713). The NVIDIA DGX-1 used for this research was donated by the NVIDIA Corporation. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            212
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            285,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marc G Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The arcade learning environment: An evaluation platform for general agents. J. Artif. Intell. Res.(JAIR), 47:253–279, 2013. ",
+        "bbox": [
+            174,
+            257,
+            826,
+            299
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1171–1179, 2015. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            353
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cameron B Browne, Edward Powley, Daniel Whitehouse, Simon M Lucas, Peter I Cowling, Philipp Rohlfshagen, Stephen Tavener, Diego Perez, Spyridon Samothrakis, and Simon Colton. A survey of monte carlo tree search methods. IEEE Transactions on Computational Intelligence and AI in games, 4(1):1–43, 2012. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            420
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Silvia Chiappa, Sebastien Racaniere, Daan Wierstra, and Shakir Mohamed. Recurrent environment ´ simulators. arXiv preprint arXiv:1704.02254, 2017. ",
+        "bbox": [
+            171,
+            430,
+            825,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Remi Coulom. Efficient selectivity and backup operators in monte-carlo tree search. In ´ Computers and Games, 5th International Conference, CG 2006, Turin, Italy, May 29-31, 2006. Revised Papers, pp. 72–83, 2006. doi: 10.1007/978-3-540-75538-8 7. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            513
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marc Deisenroth and Carl E Rasmussen. Pilco: A model-based and data-efficient approach to policy search. In Proceedings of the 28th International Conference on machine learning (ICML-11), pp. 465–472, 2011. ",
+        "bbox": [
+            173,
+            523,
+            823,
+            566
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Priya L Donti, Brandon Amos, and J Zico Kolter. Task-based end-to-end model learning. arXiv preprint arXiv:1703.04529, 2017. ",
+        "bbox": [
+            169,
+            577,
+            825,
+            606
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael Fairbank and Eduardo Alonso. Value-gradient learning. In Neural Networks (IJCNN), The 2012 International Joint Conference on, pp. 1–8. IEEE, 2012. ",
+        "bbox": [
+            171,
+            617,
+            823,
+            646
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sylvain Gelly and David Silver. Combining online and offline knowledge in uct. In Proceedings of the 24th international conference on Machine learning, pp. 273–280. ACM, 2007. ",
+        "bbox": [
+            173,
+            655,
+            823,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu, Timothy Lillicrap, Ilya Sutskever, and Sergey Levine. Continuous deep q-learning with model-based acceleration. In International Conference on Machine Learning, pp. 2829–2838, 2016. ",
+        "bbox": [
+            174,
+            695,
+            825,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Heess, Gregory Wayne, David Silver, Tim Lillicrap, Tom Erez, and Yuval Tassa. Learning continuous control policies by stochastic value gradients. In Advances in Neural Information Processing Systems, pp. 2944–2952, 2015. ",
+        "bbox": [
+            173,
+            748,
+            825,
+            791
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christopher Hesse, Matthias Plappert, Alec Radford, John Schulman, Szymon Sidor, and Yuhuai Wu. Openai baselines. https://github.com/openai/baselines, 2017. ",
+        "bbox": [
+            171,
+            803,
+            825,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Donald E Knuth and Ronald W Moore. An analysis of alpha-beta pruning. Artificial intelligence, 6 (4):293–326, 1975. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Levente Kocsis and Csaba Szepesvari. Bandit based monte-carlo planning. In ´ Machine Learning: ECML 2006, 17th European Conference on Machine Learning, Berlin, Germany, September 18-22, 2006, Proceedings, pp. 282–293, 2006. doi: 10.1007/11871842 29. ",
+        "bbox": [
+            174,
+            882,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015. doi: 10.1038/nature14236. ",
+        "bbox": [
+            176,
+            103,
+            826,
+            174
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Adria Puigdom \\` enech Badia, Mehdi Mirza, Alex Graves, Timothy P. Lillicrap, Tim \\` Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, pp. 1928–1937, 2016. ",
+        "bbox": [
+            174,
+            184,
+            826,
+            241
+        ],
+        "page_idx": 12
+    },
+    {
+        "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. ",
+        "bbox": [
+            174,
+            251,
+            823,
+            292
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L Lewis, and Satinder Singh. Action-conditional video prediction using deep networks in atari games. In Advances in Neural Information Processing Systems, pp. 2863–2871, 2015. ",
+        "bbox": [
+            171,
+            303,
+            823,
+            345
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Oh, Satinder Singh, and Honglak Lee. Value prediction network. arXiv preprint arXiv:1707.03497, 2017. ",
+        "bbox": [
+            171,
+            356,
+            825,
+            385
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Deepak Pathak, Pulkit Agrawal, Alexei A Efros, and Trevor Darrell. Curiosity-driven exploration by self-supervised prediction. arXiv preprint arXiv:1705.05363, 2017. ",
+        "bbox": [
+            173,
+            395,
+            823,
+            424
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Richard S. Sutton, and Martin Muller. Temporal-difference search in computer go.¨ Machine Learning, 87(2):183–219, 2012. doi: 10.1007/s10994-012-5280-0. ",
+        "bbox": [
+            176,
+            434,
+            821,
+            463
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap, Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. doi: 10.1038/nature16961. ",
+        "bbox": [
+            173,
+            472,
+            826,
+            556
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354–359, 2017a. ",
+        "bbox": [
+            176,
+            566,
+            825,
+            609
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Hado van Hasselt, Matteo Hessel, Tom Schaul, Arthur Guez, Tim Harley, Gabriel Dulac-Arnold, David P. Reichert, Neil Rabinowitz, Andre Barreto, and Thomas Degris. The ´ predictron: End-to-end learning and planning. In Proceedings of the 34th International Conference on Machine Learning, ICML 2017, Sydney, NSW, Australia, 6-11 August 2017, pp. 3191–3199, 2017b. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            689
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nathan R Sturtevant. An analysis of uct in multi-player games. In International Conference on Computers and Games, pp. 37–49. Springer, 2008. ",
+        "bbox": [
+            174,
+            700,
+            823,
+            729
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton. Learning to predict by the methods of temporal differences. Machine learning, 3 (1):9–44, 1988. ",
+        "bbox": [
+            173,
+            739,
+            823,
+            768
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S. Sutton. Integrated architectures for learning, planning, and reacting based on approximating dynamic programming. In Machine Learning, Proceedings of the Seventh International Conference on Machine Learning, Austin, Texas, USA, June 21-23, 1990, pp. 216–224, 1990. ",
+        "bbox": [
+            174,
+            779,
+            823,
+            821
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT press Cambridge, 1998. ",
+        "bbox": [
+            169,
+            830,
+            823,
+            859
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Erik Talvitie. Model regularization for stable sample rollouts. In UAI, pp. 780–789, 2014. ",
+        "bbox": [
+            169,
+            869,
+            763,
+            886
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Erik Talvitie. Self-correcting models for model-based reinforcement learning. In AAAI, pp. 2597– 2603, 2017. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aviv Tamar, Sergey Levine, Pieter Abbeel, Yi Wu, and Garrett Thomas. Value iteration networks. In Advances in Neural Information Processing Systems 29: Annual Conference on Neural Information Processing Systems 2016, December 5-10, 2016, Barcelona, Spain, pp. 2146–2154, 2016. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Tijmen Tieleman and Geoffrey Hinton. Lecture 6.5-rmsprop: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural networks for machine learning, 4(2):26–31, 2012. ",
+        "bbox": [
+            178,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Harm van Seijen, Shimon Whiteson, Hado van Hasselt, and Marco Wiering. Exploiting best-match equations for efficient reinforcement learning. Journal of Machine Learning Research, 12(Jun): 2045–2094, 2011. ",
+        "bbox": [
+            174,
+            207,
+            826,
+            248
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Christopher J. C. H. Watkins and Peter Dayan. Q-learning. Machine Learning, 8:279–292, 1992. doi: 10.1007/BF00992698. ",
+        "bbox": [
+            174,
+            257,
+            823,
+            286
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Theophane Weber, Sebastien Racani ´ ere, David P. Reichert, Lars Buesing, Arthur Guez, \\` Danilo Jimenez Rezende, Adria Puigdom \\` enech Badia, Oriol Vinyals, Nicolas Heess, Yujia Li, \\` Razvan Pascanu, Peter Battaglia, David Silver, and Daan Wierstra. Imagination-augmented agents for deep reinforcement learning. CoRR, abs/1707.06203, 2017. ",
+        "bbox": [
+            174,
+            295,
+            825,
+            352
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            299,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.1 BOX PUSHING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            318,
+            148
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Environment. For each episode, a new level is generated by placing an agent, 12 boxes, 5 goals and 6 obstacles in the center $6 \\times 6$ tiles of an $8 \\times 8$ grid, sampling locations uniformly. The outer tiles are left empty to prevent initial situations where boxes cannot be recovered. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            202
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The agent may move in the four cardinal directions. If the agent steps off the grid, the episode ends and the agent receives a penalty of $- 1$ . If the agent moves into a box, it is pushed in the direction of movement. Moving a box out of the grid generates a penalty of $- 0 . 1$ . Moving a box into another box is not allowed and trying to do so generates a penalty of $- 0 . 1$ while leaving all positions unchanged. When a box is pushed into a goal, it is removed and the agent receives a reward of $+ 1$ . ",
+        "bbox": [
+            174,
+            208,
+            825,
+            279
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Obstacles generate a penalty of $- 0 . 2$ when the agent or a box is moved onto them. Moving the agent over goals incurs no penalty. Lastly, at each timestep the agent receives a penalty of $- 0 . 0 1$ . Episodes terminate when 75 timesteps have elapsed, the agent has left the grid, or no boxes remain. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            327
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The observation is given to the model as a tensor of size $5 \\times 8 \\times 8$ . The first four channels are binary encodings of the position of the agent, goals, boxes, and obstacles respectively. The final channel is filled with the number of timesteps remaining (normalised by the total number of timesteps allowed). ",
+        "bbox": [
+            174,
+            333,
+            825,
+            376
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Architecture. The encoder consists of (conv-3x3-1-24, conv-3x3-1-24, conv-4x4-1-48, fc-128), where conv-wxh-s-n denotes a convolution with $n$ filters of size $w \\times h$ and stride $s$ , and fc-h denotes a fully connected layer with $h$ hidden units. All layers are separated with ReLU nonlinearities. The hidden layer of the reward function MLP has 64 hidden units. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            439
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.2 ATARI ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            457,
+            263,
+            470
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Preprocessing of inputs follows the procedure of Mnih et al. (2015), including concatenation of the last four frames as input, although we use a frameskip of 10. ",
+        "bbox": [
+            176,
+            482,
+            821,
+            511
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Architecture. The Atari experiments have the same architecture as for box-pushing, except for the encoder architecture which is as follows: (conv-8x8-4-16, conv-4x4-2-32, fc-512). ",
+        "bbox": [
+            173,
+            517,
+            823,
+            546
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3 OTHER HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            563,
+            411,
+            577
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "All experiments use RMSProp (Tieleman & Hinton, 2012) with a learning rate of 1e-4, a decay of $\\alpha = 0 . 9 9$ , and $\\epsilon = 1 \\mathrm { e } { - } 5$ . ",
+        "bbox": [
+            173,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The learning rate was tuned coarsely by running DQN on the Seaquest environment, and kept the same for all subsequent experiments (box-pushing and Atari). ",
+        "bbox": [
+            174,
+            623,
+            823,
+            652
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For DQN and TreeQN, $\\epsilon$ for $\\epsilon$ -greedy exploration was decayed linearly from 1 to 0.05 over the first 4 million environment transitions observed (after frameskipping, so over 40 million atomic Atari timesteps). ",
+        "bbox": [
+            174,
+            660,
+            825,
+            702
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "For A2C and ATreeC, we use a value-function loss coefficient $\\alpha = 0 . 5$ and an entropy regularisation $\\beta = 0 . 0 1$ . ",
+        "bbox": [
+            173,
+            708,
+            821,
+            736
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The reward prediction loss was scaled by $\\eta _ { r } = 1$ ",
+        "bbox": [
+            176,
+            743,
+            495,
+            758
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We use $n _ { \\mathrm { s t e p s } } = 5$ and $n _ { \\mathrm { e n v s } } = 1 6$ , for a total batch size of 80. ",
+        "bbox": [
+            173,
+            765,
+            573,
+            780
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "The discount factor is $\\gamma = 0 . 9 9$ and the target networks are updated every $4 0 , 0 0 0$ environment transitions. ",
+        "bbox": [
+            173,
+            786,
+            823,
+            814
+        ],
+        "page_idx": 14
+    }
+]

parse/train/HJlzxgBtwH/HJlzxgBtwH.md

@@ -0,0 +1,384 @@
+# Minimally distorted Adversarial Examples with a Fast Adaptive Boundary Attack
+
+Anonymous authors Paper under double-blind review
+
+# Abstract
+
+The evaluation of robustness against adversarial manipulations of neural networks-based classifiers is mainly tested with empirical attacks as the methods for the exact computation, even when available, do not scale to large networks. We propose in this paper a new white-box adversarial attack wrt the $l _ { p }$ -norms for $p \in \{ 1 , 2 , \infty \}$ aiming at finding the minimal perturbation necessary to change the class of a given input. It has an intuitive geometric meaning, yields quickly high quality results, minimizes the size of the perturbation (so that it returns the robust accuracy at every threshold with a single run). It performs better or similarly to state-of-the-art attacks which are partially specialized to one $l _ { p }$ -norm.
+
+# 1 Introduction
+
+The finding of the vulnerability of neural networks-based classifiers to adversarial examples, that is small perturbations of the input able to modify the decision of the models, started a fast development of a variety of attack algorithms. The high effectiveness of adversarial attacks reveals the fragility of these networks which questions their safe and reliable use in the real world, especially in safety critical applications. Many defenses have been proposed to fix this issue (Gu & Rigazio, 2015; Zheng et al., 2016; Papernot et al., 2016; Huang et al., 2016; Bastani et al., 2016; Madry et al., 2018), but with limited success, as new more powerful attacks showed (Carlini & Wagner, 2017b; Athalye et al., 2018; Mosbach et al., 2018). In order to trust the decision of a model, it is necessary to evaluate the exact adversarial robustness. Although this is possible for ReLU networks (Katz et al., 2017; Tjeng et al., 2019) these techniques do not scale to commonly used large networks. Thus, the robustness is evaluated approximating the solution of the minimal adversarial perturbation problem through adversarial attacks.
+
+One can distinguish attacks into black-box (Narodytska & Kasiviswanathan, 2016; Brendel et al., 2018; Su et al., 2019), where one is only allowed to query the classifier, and white-box attacks, where one has full control over the network, according to the attack model used to create adversarial examples (typically some $l _ { p }$ -norm, but others have become popular as well, e.g. Brown et al. (2017); Engstrom et al. (2017); Wong et al.), whether they aim at the minimal adversarial perturbation (Carlini & Wagner, 2017a; Chen et al., 2018; Croce et al., 2019) or rather any perturbation below a threshold (Kurakin et al., 2017; Madry et al., 2018; Zheng et al., 2019), if they have lower (Moosavi-Dezfooli et al., 2016; Modas et al., 2019) or higher (Carlini & Wagner, 2017a; Croce et al., 2019) computational cost. Moreover, it is clear that due to the non-convexity of the problem there exists no universally best attack (apart from the exact methods), since this depends on runtime constraints, networks architecture, dataset, etc. However, our goal is to have an attack which performs well under a broad spectrum of conditions with minimal amount of hyperparameter tuning.
+
+In this paper we propose a new white-box attacking scheme which performs comparably or better than established attacks and has the following features: first, it tries to produce adversarial samples with minimal distortion compared to the original point, measured wrt the $l _ { p }$ -norms with $p \in \{ 1 , 2 , \infty \}$ . Respect to the quite popular PGD-attack of Madry et al. (2018) this has the clear advantage that our method does not need to be restarted for every threshold $\epsilon$ if one wants to evaluate the success rate of the attack with perturbations constrained to be in $\{ \delta \in \mathbb { R } ^ { d } \mid \left\| \delta \right\| _ { p } \leq \epsilon \}$ . Thus it is particularly suitable to get a complete picture on the robustness of a classifier with low computational cost. Second, it achieves fast good quality in terms of average distortion or robust accuracy. At the same time we show that increasing the number of restarts keeps improving the results and makes it competitive with the strongest available attacks. Third, although it comes with a few parameters, these mostly generalize across datasets, architectures and norms considered, so that we have an almost off-the-shelf method. Most importantly, unlike PGD and other methods, there is no step size parameter which potentially has to be carefully adapted to every new network.
+
+# 2 FAB: a Fast Adaptive Boundary Attack
+
+We first introduce minimal adversarial perturbations, then we recall the definition and properties of the projection wrt the $l _ { p }$ -norms of a point on the intersection of a hyperplane and box constraints, as they are an essential part of our attack. Finally, we present our FAB-attack algorithm to generate minimally distorted adversarial examples.
+
+# 2.1 Minimal adversarial examples
+
+Let $f : \mathbb { R } ^ { d }  \mathbb { R } ^ { K }$ be a classifier which assigns every input $x \in \mathbb { R } ^ { d }$ (with $d$ the dimension of the input space) to one of the $K$ classes according to arg max $f _ { r } ( x )$ . In many scenarios $r { = } 1 , { \ldots } , K$
+
+the input of $f$ has to satisfy a specific set of constraints $C$ , e.g. images are represented as elements of $[ 0 , 1 ] ^ { d }$ . Then, given a point $x \in \mathbb { R } ^ { d }$ with true class $c$ , we define the minimal adversarial perturbation for $x$ wrt the $l _ { p }$ -norm as
+
+$$
+\delta _ { \operatorname* { m i n } , p } = \operatorname* { a r g m i n } _ { \delta \in \mathbb { R } ^ { d } } \ \| \delta \| _ { p } , \quad \mathrm { s . t h . } \quad \operatorname* { m a x } _ { l \neq c } \ f _ { l } ( x + \delta ) \geq f _ { c } ( x + \delta ) , \quad x + \delta \in C .
+$$
+
+The optimization problem (1) is non-convex and NP-hard for non-trivial classifiers (Katz et al. (2017)) and, although for some classes of networks it can be formulated as a mixed-integer program (see Tjeng et al. (2019)), the computational cost of solving it is prohibitive for large, normally trained networks. Thus, $\delta _ { \mathrm { m i n } , p }$ is usually approximated by an attack algorithm, which can be seen as a heuristic to solve (1). We will see in the experiments that current attacks sometimes drastically overestimate $\Vert \delta _ { \mathrm { m i n } , p } \Vert _ { p }$ and thus the robustness of the networks.
+
+# 2.2 Projection on a hyperplane with box constraints
+
+Let $w ~ \in ~ \mathbb { R } ^ { d }$ and $b \in \mathbb { R }$ be the normal vector and the offset defining the hyperplane $\pi : \langle w , x \rangle + b = 0$ . Let $x \in \mathbb { R } ^ { d }$ , we denote by the box-constrained projection wrt the $l _ { p }$ -norm of $x$ on $\pi$ (projection onto the intersection of the box $C = \{ z \in \mathbb { R } ^ { d } : l _ { i } \leq z _ { i } \leq u _ { i } \}$ and the hyperplane $\pi$ ) the following minimization problem:
+
+$$
+z ^ { * } = \underset { z \in \mathbb { R } ^ { d } } { \mathrm { a r g } \mathrm { m i n } } \ \lVert z - x \rVert _ { p } \quad \mathrm { s . t h . } \quad \langle w , z \rangle + b = 0 , \quad l _ { i } \leq z _ { i } \leq u _ { i } , \quad i = 1 , \ldots , d ,
+$$
+
+where $l _ { i } , u _ { i } \in \mathbb { R }$ are lower and upper bounds on each component of $z$ . For $p \geq 1$ the optimization problem (2) is convex. Hein $\&$ Andriushchenko (2017) proved that for $p \in$ $\{ 1 , 2 , \infty \}$ the solution can be obtained in ${ \mathcal { O } } ( d \log d )$ time, that is the complexity of sorting a vector of $d$ elements, as well as determining that it has no solution.
+
+Since this projection is part of our iterative scheme, we need to handle specifically the case of (2) being infeasible. In this case, defining $\rho = \mathrm { s i g n } ( \langle w , x \rangle + b )$ , we instead compute
+
+$$
+z ^ { \prime } = \underset { z \in \mathbb { R } ^ { d } } { \arg \operatorname* { m i n } } \ \rho ( \langle w , z \rangle + b ) \quad \mathrm { s . t h . } \quad l _ { i } \leq z _ { i } \leq u _ { i } , \quad i = 1 , \ldots , d ,
+$$
+
+$z _ { i } = \left\{ { \begin{array} { l } { l _ { i } } \\ { u _ { i } } \\ { x _ { i } } \end{array} } \right.$ if $\rho w _ { i } > 0$ , whose solution is given componentwise, for every $i = 1 , \ldots , d$ , by if $\rho w _ { i } < 0 , .$ if $w _ { i } = 0$
+
+Assuming that the point $x$ satisfies the box constraints (as it will be in our algorithm), this is equivalent to identifying the corner of the $d$ -dimensional box defined by the componentwise constraints on $z$ closest to the hyperplane $\pi$ . Notice that if (2) is infeasible then the objective
+
+function of (3) stays positive and the points $x$ and $z$ are strictly contained in the same of the two halfspaces divided by $\pi$ . Finally, we define the operator
+
+$$
+\mathrm { p r o j } _ { p } : ( x , \pi , C ) \longmapsto { \left\{ \begin{array} { l l } { z ^ { * } } & { { \mathrm { i f ~ } } \mathrm { P r o b l e m ~ ( 2 ) ~ i s ~ f e a s i b l e } } \\ { z ^ { \prime } } & { { \mathrm { e l s e } } } \end{array} \right. }
+$$
+
+yielding the point which gets as close as possible to $\pi$ without violating the box constraints.
+
+# 2.3 FAB Attack
+
+We introduce now our algorithm to produce minimally distorted adversarial examples, wrt any $l _ { p }$ -norm for $p \in \{ 1 , 2 , \infty \}$ , for a given point $x _ { \mathrm { o r i g } }$ initially correctly classified by $f$ as class $c$ . The high-level idea is that we use the linearization of the classifier at the current iterate $\boldsymbol { x } ^ { ( i ) }$ , compute the box-constrained projections of $\boldsymbol { x } ^ { ( i ) }$ respectively $x _ { \mathrm { o r i g } }$ onto the approximated decision hyperplane and take a convex combinations of these projections depending on the distance of $\boldsymbol { x } ^ { ( i ) }$ and to the decision hyperplane, followed by some extrapolation step. $x _ { \mathrm { o r i g } }$   
+We explain below the geometric motivation behind these steps. The attack closest in spirit is DeepFool (Moosavi-Dezfooli et al. (2016)) which is known to be very fast but suffers from low quality. DeepFool just tries to find the decision boundary quickly but has no incentive to provide a solution close to $x _ { \mathrm { o r i g } }$ . Our scheme resolves this main problem and, together with the exact projection we use, leads to a principled way to track the decision boundary (the surface where the decision of $f$ changes) close to $x _ { \mathrm { o r i g } }$ .
+
+If $f$ was a linear classifier then the closest point to $\boldsymbol { x } ^ { ( i ) }$ on the decision hyperplane could be found in closed form. Although neural networks are highly non-linear, ReLU networks (neural networks which use ReLU as activation function) are piecewise affine functions and thus locally a linearization of the network is an exact description of the classifier. Let $l \neq c$ , then the decision boundary between classes $\it l$ and $c$ can be locally approximated using a first order Taylor expansion at $\boldsymbol { x } ^ { ( i ) }$ by the hyperplane
+
+$$
+\pi \iota ( z ) : f _ { l } ( x ^ { ( i ) } ) - f _ { c } ( x ^ { ( i ) } ) + \left. \nabla f _ { l } ( x ^ { ( i ) } ) - \nabla f _ { c } ( x ^ { ( i ) } ) , z - x ^ { ( i ) } \right. = 0 .
+$$
+
+Moreover the $l _ { p }$ -distance $d _ { p } ( \pi , x ^ { ( i ) } )$ of $\boldsymbol { x } ^ { ( i ) }$ to $\pi _ { l }$ is given by
+
+$$
+d _ { p } ( \pi _ { l } , x ^ { ( i ) } ) = \frac { | f _ { l } ( x ^ { ( i ) } ) - f _ { c } ( x ^ { ( i ) } ) | } { \left\| \nabla f _ { l } ( x ^ { ( i ) } ) - \nabla f _ { c } ( x ^ { ( i ) } ) \right\| _ { q } } , \quad \mathrm { w i t h } \quad \frac { 1 } { p } + \frac { 1 } { q } = 1 .
+$$
+
+Note that if $d _ { p } ( \pi _ { l } , x ^ { ( i ) } ) = 0$ then $\boldsymbol { x } ^ { ( i ) }$ belongs to the true decision boundary. Moreover, if the local linear approximation of the network is correct then the class $s$ with the decision hyperplane closest to the point $\boldsymbol { x } ^ { ( i ) }$ can be computed as
+
+$$
+s = \underset { l \neq c } { \arg \operatorname* { m i n } } \frac { \lvert f _ { l } ( \boldsymbol { x } ^ { ( i ) } ) - f _ { c } ( \boldsymbol { x } ^ { ( i ) } ) \rvert } { \left. \nabla f _ { l } ( \boldsymbol { x } ^ { ( i ) } ) - \nabla f _ { c } ( \boldsymbol { x } ^ { ( i ) } ) \right. _ { q } } .
+$$
+
+Thus, given that the approximation holds in some large enough neighborhood, the projection $\mathrm { p r o j } _ { p } ( \boldsymbol { x } ^ { ( i ) } , \pi _ { s } , C )$ of $x ^ { ( i ) }$ onto $\pi _ { s }$ lies on the decision boundary (unless (2) is infeasible).
+
+Biased gradient step: The iterative algorithm $\begin{array} { r } { \boldsymbol { x } _ { . } ^ { ( i + 1 ) } = \mathrm { p r o j } _ { p } ( \boldsymbol { x } ^ { ( i ) } , \pi _ { s } , C ) } \end{array}$ would be similar to DeepFool except that our projection operator is exact whereas they project onto the hyperplane and then clip to $[ 0 , 1 ] ^ { d }$ . This scheme is not biased towards the original target point $x _ { \mathrm { o r i g } }$ , thus it goes typically further than necessary to find a point on the decision boundary as basically the algorithm does not aim at the minimal adversarial perturbation. Thus we consider additionally $\mathrm { p r o j } _ { p } ( x _ { \mathrm { o r i g } } , \pi _ { s } , C )$ and use instead the iterative step, with $x ^ { ( 0 ) } = x _ { \mathrm { o r i g } }$ , defined as
+
+$$
+x ^ { ( i + 1 ) } = ( 1 - \alpha ) \cdot \mathrm { p r o j } _ { p } ( x ^ { ( i ) } , \pi _ { s } , C ) + \alpha \cdot \mathrm { p r o j } _ { p } ( x _ { \mathrm { o r i g } } , \pi _ { s } , C ) ,
+$$
+
+which biases the step towards $x _ { \mathrm { o r i g } }$ (see Figure 1). Note that this is a convex combination of two points on $\pi _ { s }$ and in $C$ and thus also $x ^ { ( i + 1 ) }$ lies on $\pi _ { s }$ and is contained in $C$ . As we wish
+
+![](images/61ed5aa11b8b88c56205a2e11f05df1d055acd5f0879cc50a81c5020bc1a1661.jpg)  
+Figure 1: Visualization of FAB-attack scheme, with on the left the case $\eta = 1$ , on the right $\eta > 1$ . In blue we represent the next iterate $x ^ { ( i + 1 ) }$ one would get without any bias toward the original point , in green the effect of the bias we introduce and in red the $x ^ { ( i + 1 ) }$ $x _ { \mathrm { o r i g } }$ obtained with our scheme in (10). We see that our algorithm tends to stay closer to the original point compared to the one with an unbiased gradient step.
+
+a scheme with minimal amount of parameters, we want to have an automatic selection of $\alpha$ based on the available geometric quantities. Let
+
+$$
+\delta ^ { ( i ) } = \mathrm { p r o j } _ { p } ( x ^ { ( i ) } , \pi _ { s } , C ) - x ^ { ( i ) } \quad \mathrm { ~ a n d ~ } \quad \delta _ { \mathrm { o r i g } } ^ { ( i ) } = \mathrm { p r o j } _ { p } ( x _ { \mathrm { o r i g } } , \pi _ { s } , C ) - x _ { \mathrm { o r i g } } .
+$$
+
+Note that $\left. \delta ^ { ( i ) } \right. _ { p }$ and $\left\| \delta _ { \mathrm { o r i g } } ^ { ( i ) } \right\| _ { p }$ are the distances of $\boldsymbol { x } ^ { ( i ) }$ and to (inside $C$ ). We $x _ { \mathrm { o r i g } }$ $\pi _ { s }$ propose to use for the parameter $\alpha$ the relative magnitude of these two distances, that is
+
+$$
+\alpha = \operatorname* { m i n } \left\{ \frac { \left\| \delta ^ { ( i ) } \right\| _ { p } } { \left\| \delta ^ { ( i ) } \right\| _ { p } + \left\| \delta _ { \mathrm { o r i g } } ^ { ( i ) } \right\| _ { p } } , \alpha _ { \mathrm { m a x } } \right\} \in [ 0 , 1 ] .
+$$
+
+The motivation for doing so is that if $\boldsymbol { x } ^ { ( i ) }$ is close to the decision boundary, then we should stay close to this point (note that $\pi _ { s }$ is the approximation of $f$ computed at $\boldsymbol { x } ^ { ( i ) }$ and thus it is valid in a small neighborhood of $\boldsymbol { x } ^ { ( i ) }$ , whereas is farther away). On the other hand we want to have the bias towards $x _ { \mathrm { o r i g } }$ in order not to go too far away from $x _ { \mathrm { o r i g } }$ . This is why $\alpha$ depends on the distances of $\boldsymbol { x } ^ { ( i ) }$ and $x _ { \mathrm { o r i g } }$ to $\pi _ { s }$ but we limit it from above with $\alpha _ { \mathrm { m a x } }$ . Finally, we use a small extrapolation step as we noted empirically, similarly to Moosavi-Dezfooli et al. (2016), that this helps to cross faster the decision boundary and get an adversarial sample. This leads to the final scheme:
+
+$$
+x ^ { ( i + 1 ) } = \mathrm { p r o j } _ { C } \Big ( ( 1 - \alpha ) ( x ^ { ( i ) } + \eta \delta ^ { ( i ) } ) + \alpha ( x _ { \mathrm { o r i g } } + \eta \delta _ { \mathrm { o r i g } } ^ { ( i ) } ) \Big ) ,
+$$
+
+where $\alpha$ is chosen as in (9), $\eta \geq 1$ and proj is just the projection onto the box which can be $C$   
+done by clippinand the vectors Figuand we visualize the scheme: in black one can see the hyperplane , in blue the step we would make going to the decision bounda $\pi _ { s }$ $\delta _ { \mathrm { o r i g } } ^ { ( i ) }$ $\delta ^ { ( i ) }$   
+with the DeepFool variant, while in red the actual step we have in our method. The green   
+vector represents instead the bias towards the original point we introduce. On the left of   
+Figure 1 we use $\eta = 1$ , while on the right we use overshooting $\eta > 1$ .
+
+Interpretation of $\mathbf { p r o j } _ { p } ( x _ { \mathbf { o r i g } } , \pi _ { s } , C )$ : The projection of the target point onto the intersection of $\pi _ { s }$ and $C$ is defined as
+
+$$
+\operatorname * { a r g m i n } _ { z \in \mathbb { R } ^ { d } } \left\| z - x _ { \mathrm { o r i g } } \right\| _ { p } \mathrm { \quad { s . t h . \quad } } \left. w , z \right. + b = 0 , \quad l _ { i } \leq z _ { i } \leq u _ { i } ,
+$$
+
+Note that replacing $z$ by $\boldsymbol { x } ^ { ( i ) } + \delta$ we can rewrite this as
+
+$$
+\underset { \delta \in \mathbb R ^ { d } } { \arg \operatorname* { m i n } } \left\| x ^ { ( i ) } + \delta - x _ { \mathrm { o r i g } } \right\| _ { p } \quad \mathrm { s . t h . } \quad \langle w , x + \delta \rangle + b = 0 , \quad l _ { i } \leq x _ { i } + \delta _ { i } \leq u _ { i } .
+$$
+
+This can be interpreted as the minimization of the distance of the next iterate $\boldsymbol { x } ^ { ( i ) } + \delta$ to the target point $x _ { \mathrm { o r i g } }$ so that $\boldsymbol { x } ^ { ( i ) } + \delta$ lies on the intersection of the (approximate) decision hyperplane and the box $C$ . This point of view on the projection $\mathrm { p r o j } _ { p } ( x _ { \mathrm { o r i g } } , \pi _ { s } , C )$ again justifies using a convex combination of the two projections in our iterative scheme in (10).
+
+Backward step: The described scheme finds in a few iterations adversarial perturbations. However, we are interested in minimizing their norms. Thus, once we have a new point $x ^ { ( i + 1 ) }$ , we check whether it is assigned by $f$ to a class different from $c$ . In this case, we apply
+
+$$
+x ^ { ( i + 1 ) } = ( 1 - \beta ) x _ { \mathrm { o r i g } } + \beta x ^ { ( i + 1 ) } , \quad \beta \in ( 0 , 1 ) ,
+$$
+
+that is we go back towards $x _ { \mathrm { o r i g } }$ on the segment $[ x ^ { ( i + 1 ) } , x _ { \mathrm { o r i g } } ]$ , effectively starting again the algorithm at a point which is quite close to the decision boundary. In this way, due to the bias of the method towards $x _ { \mathrm { o r i g } }$ we successively find adversarial perturbations of smaller norm, meaning that the algorithm tracks the decision boundary while getting closer to $x _ { \mathrm { o r i g } }$
+
+Final search: Our scheme finds points close to the decision boundary but often they are slightly off as the linear approximation is not exact and we apply the extrapolation step with $\eta > 1$ . Thus, after finishing $N _ { \mathrm { i t e r } }$ iterations of our algorithmic scheme, we perform a last, fast step to further improve the quality of the adversarial examples. Let $x _ { \mathrm { o u t } }$ be the closest point to $x _ { \mathrm { o r i g } }$ classified differently from $c$ , say $s \neq c$ , found with the iterative scheme. It holds that $f _ { s } ( x _ { \mathrm { o u t } } ) - f _ { c } ( x _ { \mathrm { o u t } } ) > 0$ and $f _ { s } ( x _ { \mathrm { o r i g } } ) - f _ { c } ( x _ { \mathrm { o r i g } } ) < 0$ . This means that, assuming $f$ continuous, there exists a point $x ^ { * }$ on the segment $[ x _ { \mathrm { o u t } } , x _ { \mathrm { o r i g } } ]$ such that $f _ { s } ( x ^ { * } ) - f _ { c } ( x ^ { * } ) = 0$ and $\left\| x ^ { * } - x _ { \mathrm { o r i g } } \right\| _ { p } < \left\| x _ { \mathrm { o u t } } - x _ { \mathrm { o r i g } } \right\| _ { p }$ . If $f$ is linear
+
+$$
+x ^ { * } = x _ { \mathrm { o u t } } - { \frac { f _ { s } ( x _ { \mathrm { o u t } } ) - f _ { c } ( x _ { \mathrm { o u t } } ) } { f _ { s } ( x _ { \mathrm { o u t } } ) - f _ { c } ( x _ { \mathrm { o u t } } ) + f _ { s } ( x _ { \mathrm { o r i g } } ) - f _ { c } ( x _ { \mathrm { o r i g } } ) } } ( x _ { \mathrm { o u t } } - x _ { \mathrm { o r i g } } ) .
+$$
+
+Since $f$ is typically non-linear, but close to linear, we compute iteratively for a few steps
+
+$$
+x _ { \mathrm { { t e m p } } } = x _ { \mathrm { { o u t } } } - { \frac { f _ { s } ( x _ { \mathrm { { o u t } } } ) - f _ { c } ( x _ { \mathrm { { o u t } } } ) } { f _ { s } ( x _ { \mathrm { { o u t } } } ) - f _ { c } ( x _ { \mathrm { { o u t } } } ) + f _ { s } ( x _ { \mathrm { { o r i g } } } ) - f _ { c } ( x _ { \mathrm { { o r i g } } } ) } } ( x _ { \mathrm { { o u t } } } - x _ { \mathrm { { o r i g } } } ) ,
+$$
+
+each time replacing in (13) $x _ { \mathrm { o u t } }$ with $x _ { \mathrm { t e m p } }$ if $f _ { s } ( x _ { \mathrm { t e m p } } ) - f _ { c } ( x _ { \mathrm { t e m p } } ) > 0$ or $x _ { \mathrm { o r i g } }$ with $x _ { \mathrm { t e m p } }$ if instead $f _ { s } ( x _ { \mathrm { t e m p } } ) - f _ { c } ( x _ { \mathrm { t e m p } } ) < 0$ . With this kind of modified binary search one can find a better adversarial sample with the cost of a few forward passes of the network.
+
+Random restarts: So far all the steps are deterministic. To improve the results, we introduce the option of random restarts, that is $x ^ { ( 0 ) }$ is randomly sampled in proximity of $x _ { \mathrm { o r i g } }$ instead of being $x _ { \mathrm { o r i g } }$ itself. Most attacks benefit from random restarts, e.g. Madry et al. (2018); Zheng et al. (2019), especially dealing with gradient-masking defenses (Mosbach et al. (2018)), as it allows a wider exploration of the input space. We choose to sample from the $l _ { p }$ -sphere centered in the original point with radius half the $l _ { p }$ -norm of the current best adversarial perturbation (or a given threshold if no adversarial example has been found yet).
+
+Computational cost: Our attack, in Algorithm 1, consists of two main operations: the computation of $f$ and its gradients and solving the projection (2). We perform, for each iteration, a forward and a backward pass of the network in the gradient step and a forward pass in the backward step. The projection can be efficiently implemented to run in batches on the GPU and its complexity depends only on the input dimension. Thus, except for shallow models, its cost is much smaller than the passes through the network. We can approximate the computational cost of our algorithm by the total number of calls of the classifier
+
+$$
+N _ { \mathrm { i t e r } } \times N _ { \mathrm { r e s t a r t s } } \times ( 2 \times \mathrm { f o r w a r d ~ p a s s e s } + 1 \times \mathrm { b a c k w a r d ~ p a s s } ) .
+$$
+
+One has to add the forward passes for the final search, fixed to 3, that happens just once.
+
+# 2.4 Comparison to DeepFool
+
+The idea of exploiting the first order local approximation of the decision boundary is not novel but the basis of one of the first white-box adversarial attacks, DeepFool (DF) from Moosavi-Dezfooli et al. (2016). While DF and our FAB-attack share the strategy of using a linear approximation of the classifier and projecting on the decision hyperplanes, we want to point out many key differences: first, DF does not solve the projection (2) but its simpler version without box constraints, clipping afterwards. Second, their gradient step does not have any bias towards the original point, that is equivalent to $\alpha = 0$ in (10). Third, DF does
+
+# Algorithm 1: FAB-attack
+
+Input : $x _ { \mathrm { o r i g } }$ original point, $c$ original class, $N _ { \mathrm { r e s t a r t s } } , N _ { \mathrm { i t e r } } , \alpha _ { \mathrm { m a x } } , \beta , \eta , \epsilon , p$   
+Output : $x _ { \mathrm { o u t } }$ adversarial example   
+1 $u  + \infty$   
+2 for $j = 1 , \ldots , N _ { r e s t a r t s }$ do   
+3 if $j = 1$ then $x ^ { ( 0 ) }  x _ { \mathrm { o r i g } }$ ;   
+4 else $x ^ { ( 0 ) } \gets$ randomly sampled s.th. $\left. x ^ { ( 0 ) } - x _ { \mathrm { o r i g } } \right. _ { p } = \operatorname* { m i n } \{ u , \epsilon \} / 2$ ;   
+5 for $i = 0 , \ldots , N _ { i t e r } - 1$ do   
+6 $\begin{array} { r } { s \gets \underset { l \neq c } { \arg \operatorname* { m i n } } \frac { | f _ { l } ( x ^ { ( i ) } ) - f _ { c } ( x ^ { ( i ) } ) | } { \left\| \nabla f _ { l } ( x ^ { ( i ) } ) - \nabla f _ { c } ( x ^ { ( i ) } ) \right\| _ { q } } } \end{array}$   
+7 δ(i) ← projp(x(i), πs, C)   
+8 δ(i)orig ← projp(xorig, πs, C)   
+9 compute $\alpha$ as in Equation (9)   
+10 $\begin{array} { r } { x ^ { ( i + 1 ) }  \mathrm { p r o j } _ { C } \Big ( ( 1 - \alpha ) ( x ^ { ( i ) } + \eta \delta ^ { ( i ) } ) + \alpha \big ( x _ { \mathrm { o r i g } } + \eta \delta _ { \mathrm { o r i g } } ^ { ( i ) } \big ) \Big ) } \end{array}$   
+11 if $x ^ { ( i + 1 ) }$ is not classified in $c$ then   
+12 if $\left\| x ^ { ( i + 1 ) } - x _ { o r i g } \right\| _ { p } < u$ then   
+13 xout ← x(i+1)   
+14 u ← 
+15 end   
+16 $x ^ { ( i + 1 ) } \gets ( 1 - \beta ) x _ { \mathrm { o r i g } } + \beta x ^ { ( i + 1 ) }$   
+17 end   
+18 end   
+19 end   
+20 perform 3 steps of final search on $x _ { \mathrm { o u t } }$ as in (13)
+
+![](images/c36d6befcaeaf09f239f81e0fdfe2fc4bf7e25ae495c809b46c51d2545890baf.jpg)  
+Figure 2: Ablation study to DeepFool for $l _ { \infty }$ -attacks. The introduction of the convex combination ( $\alpha _ { \mathrm { m a x } } = 0 . 1$ , no backward step) already improves over DeepFool. Moreover, if one does our full approach, the case $\alpha _ { \mathrm { m a x } } = 0$ (can be seen as an improved iterative DeepFool) is worse than $\alpha _ { \mathrm { m a x } } = 0 . 1$ with the same number of restarts. In the plots we show the robust accuracy as a function of the threshold $\epsilon$ under the different attacks on the ${ \mathit { l } } _ { \infty }$ -AT model on MNIST.
+
+not have any backward step, final search or restart, as it stops as soon as a misclassified point is found (its goal is to provide quickly an adversarial perturbation of average quality). We perform an ablation study of the differences to DF in Figure 2, where we show the curves of the robust accuracy as a function of the threshold $\epsilon$ (lower is better). We present the results of DeepFool (blue) and FAB-attack with the following variations: $\alpha _ { \mathrm { m a x } } = 0 . 1$ and no backward step (magenta), $\alpha _ { \mathrm { m a x } } = 0$ (that is no bias in the gradient step) and no restarts (light green), $\alpha _ { \mathrm { m a x } } = 0 . 1$ and no restarts (orange), $\alpha _ { \mathrm { m a x } } = 0$ and 100 restarts (dark green) and $\alpha _ { \mathrm { m a x } } = 0 . 1$ and 100 restarts, that is FAB-attack, (red). We can see how every addition we make to the original scheme of DeepFool contributes to the significantly improved performance of FAB-attack when compared to the original DeepFool.
+
+# 3 Experiments
+
+Models: We run experiments on MNIST, CIFAR-10 (Krizhevsky et al.) and Restricted ImageNet (Tsipras et al. (2019)). For each dataset we consider a naturally trained model (plain) and two adversarially trained ones as in Madry et al. (2018), one to achieve robustness wrt the ${ \mathit { l } } _ { \infty }$ -norm ( $\imath _ { \infty }$ -AT) and the other wrt the $l _ { 2 }$ -norm ( $l _ { 2 }$ -AT) (see A.1).
+
+Attacks: We compare the performances of FAB-attack to those of attacks representing the state-of-the-art in each norm: DeepFool (DF) (Moosavi-Dezfooli et al. (2016)), CarliniWagner $l _ { 2 }$ -attack (CW) (Carlini & Wagner (2017a)), Linear Region $l _ { 2 }$ -Attack (LRA) (Croce et al. (2019)), Projected Gradient Descent on the cross-entropy function (PGD) (Kurakin et al., 2017; Madry et al., 2018; Tramèr & Boneh, 2019), Distributionally Adversarial Attack (DAA) (Zheng et al. (2019)), SparseFool (SF) (Modas et al. (2019)), Elastic-net Attack (EAD) (Chen et al. (2018)). We use DF from Rauber et al. (2017), CW and EAD as in Papernot et al. (2017), DAA and LRA with the code from the original papers, while we reimplemented SF and PGD. For MNIST and CIFAR-10 we used DAA with 50 restarts, PGD and FAB with 100 restarts. For Restricted ImageNet, we used DAA, PGD and FAB with 10 restarts (for $l _ { 1 }$ we used 5 restarts, since both methods benefit from more iterations). Moreover, we could not use LRA since it hardly scales to such models and CW and EAD for compatibility issues between the implementations of attacks and models. See A.2 for more details e.g. regarding number of iterations and other hyperparameters.
+
+Evaluation metrics: The robust accuracy of a model at a threshold $\epsilon$ is defined as the classification accuracy (in percentage) the model achieves when an attack is allowed to change every input of the test set with perturbations of $l _ { p }$ -norm smaller than $\epsilon$ in order to change the decision. Thus stronger attacks produce lower robust accuracies. For each model and dataset we fix five thresholds at which we compute the robust accuracy for each attack (we choose the thresholds to have values of the robust accuracy that cover the range between clean accuracy and $0$ ). We evaluate the attacks through the following statistics: i) avg. rob. accuracy: the mean of all the values of robust accuracy given by the attack over all models and thresholds, ii) # best: how many times the attack achieves the lowest robust accuracy (it is the most effective), iii) avg. difference to best: for each model/threshold we compute the difference between the robust accuracy of the attack and the best one across all the attacks, then we average over all models/thresholds, iv) max difference to best: as "avg. difference to best", but with the maximum difference instead of the average one. In A.4 we report the average $l _ { p }$ -norm of the adversarial perturbations given by the attacks.
+
+Results: We report the complete results in Tables 5 to 13 of the Appendix, while we summarize them in Tables 1 (MNIST and CIFAR-10 aggregated, as we used the same attacks) and 2 (Restricted ImageNet). Our FAB-attack achieves the best results in all statistics for every norm (with the only exception of "max diff. to best" in ${ \mathit { l } } _ { \infty }$ ) on MNIST $^ +$ CIFAR-10, meaning that it is the most effective attack. In particular, while on ${ \mathit { l } } _ { \infty }$ the "avg. robust accuracy" of PGD is not far from that of FAB, the gap is large when considering $l _ { 2 }$ and $l _ { 1 }$ . Interestingly, the second best attack, at least in terms of average robust accuracy, is different for every norm (PGD for ${ \mathit { l } } _ { \infty }$ , LRA for $l _ { 2 }$ , EAD for $l _ { 1 }$ ), which implies that FAB outperforms algorithms specialized in the individual norms.
+
+We also report the results of FAB-10, that is our attack with only 10 restarts, to show that FAB yields high quality results already with a low budget in terms of time/computational cost. In fact, FAB-10 has "avg. robust accuracy" better than or very close to that of the strongest versions of the other methods (see below for a runtime analysis, where one observes that FAB-10 is the fastest attack excluding DF and SF which however give much worse results). On Restricted ImageNet, FAB-attack gets the best results in all statistics for $l _ { 1 }$ , while for ${ \mathit { l } } _ { \infty }$ and $l _ { 2 }$ , although PGD performs often better, the difference in "avg. robust accuracy" is small, meaning that FAB performs mostly similarly to PGD.
+
+Table 1: Performance summary of all attacks on MNIST and CIFAR-10 (aggregated). We report, for each norm, "avg. rob. acc.", the mean of the values of robust accuracy across all the models and datasets, "# best", number of times the attack is the best one, "avg. diff. to best" and "max diff. to best", the mean and maximum differences between the robust accuracy of the attack and that of the best attack for each model/threshold (on the first 1000 points for $l _ { \infty }$ and $l _ { 1 }$ , 500 for $l _ { 2 }$ , of the test sets). The numbers after the name of the attacks indicates the number of restarts used. In total we consider 5 thresholds $\times \textup { 6 }$ models $= 3 0$ cases for each of the 3 norms. \*Note that for FAB-10 (i.e. with 10 restarts) the "# best" is computed excluding the results of FAB-100.
+
+statistics on MNIST $^ +$ CIFAR-10   
+
+<table><tr><td rowspan=2 colspan=1>loo-norm</td><td rowspan=2 colspan=3></td><td rowspan=2 colspan=1>DF</td><td rowspan=2 colspan=1>DAA-50</td><td rowspan=2 colspan=1>PGD-100</td><td rowspan=2 colspan=1>FAB-10</td><td></td></tr><tr><td rowspan=1 colspan=1>FAB-100</td></tr><tr><td rowspan=1 colspan=1>avg.rob.acc.</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1>58.81</td><td rowspan=1 colspan=1>60.67</td><td rowspan=1 colspan=1>46.07</td><td rowspan=1 colspan=1>46.18</td><td rowspan=2 colspan=1>45.4717</td></tr><tr><td rowspan=3 colspan=1>#bestavg. diff. to bestmax diff. to best</td><td rowspan=3 colspan=3></td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>13*</td></tr><tr><td rowspan=2 colspan=1>14.5878.10</td><td rowspan=1 colspan=1>16.45</td><td rowspan=1 colspan=1>1.85</td><td rowspan=2 colspan=1>1.9620.30</td><td rowspan=2 colspan=1>1.2517.10</td></tr><tr><td rowspan=1 colspan=1>49.00</td><td rowspan=1 colspan=1>10.70</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=2 colspan=1>FAB-10</td><td rowspan=2 colspan=1>FAB-100</td></tr><tr><td rowspan=1 colspan=1>l2-norm</td><td rowspan=1 colspan=3>CW</td><td rowspan=1 colspan=1>DF</td><td rowspan=1 colspan=1>LRA</td><td rowspan=1 colspan=1>PGD-100</td></tr><tr><td rowspan=1 colspan=1>avg.rob.acc.</td><td rowspan=1 colspan=3>45.09</td><td rowspan=1 colspan=1>56.10</td><td rowspan=1 colspan=1>36.97</td><td rowspan=1 colspan=1>44.94</td><td rowspan=1 colspan=1>36.41</td><td rowspan=4 colspan=1>35.57230.131.60</td></tr><tr><td rowspan=2 colspan=1>#bestavg. diff. to best</td><td rowspan=2 colspan=3>49.65</td><td rowspan=2 colspan=1>120.67</td><td rowspan=1 colspan=1>9</td><td rowspan=1 colspan=1>11</td><td rowspan=1 colspan=1>19*</td><td rowspan=3 colspan=1>19*0.988.40</td></tr><tr><td rowspan=1 colspan=1>1.54</td><td rowspan=1 colspan=1>9.51</td><td></td></tr><tr><td rowspan=1 colspan=1>max diff. to best</td><td rowspan=1 colspan=3>65.40</td><td rowspan=1 colspan=1>91.40</td><td rowspan=1 colspan=1>13.60</td><td rowspan=1 colspan=1>64.80</td><td></td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1></td><td rowspan=2 colspan=1>LRA</td><td rowspan=2 colspan=1>PGD-100</td><td rowspan=2 colspan=1>FAB-10</td><td rowspan=2 colspan=1>FAB-100</td></tr><tr><td rowspan=1 colspan=1>l2-norm wo/Madry&#x27;s model</td><td rowspan=1 colspan=3>CW</td><td rowspan=1 colspan=1>DF</td></tr><tr><td rowspan=1 colspan=1>avg.rob.acc.</td><td rowspan=1 colspan=3>40.85</td><td rowspan=1 colspan=1>49.18</td><td rowspan=1 colspan=1>40.25</td><td rowspan=1 colspan=1>42.95</td><td rowspan=1 colspan=1>39.98</td><td rowspan=4 colspan=1>39.57180.161.60</td></tr><tr><td rowspan=3 colspan=1># best avg. diff. to best max diff. to best</td><td rowspan=2 colspan=3>41.44</td><td rowspan=2 colspan=1>19.78</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>11</td><td rowspan=3 colspan=1>14*0.574.20</td></tr><tr><td rowspan=1 colspan=1>0.84</td><td rowspan=1 colspan=1>3.54</td></tr><tr><td rowspan=1 colspan=3>8.80</td><td rowspan=1 colspan=1>44.00</td><td rowspan=1 colspan=1>4.00</td><td rowspan=1 colspan=1>22.00</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1></td><td rowspan=2 colspan=1>EAD</td><td rowspan=2 colspan=1>PGD-100</td><td rowspan=2 colspan=1>FAB-10</td><td rowspan=2 colspan=1>FAB-100</td></tr><tr><td rowspan=1 colspan=1>l1-norm</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1>SF</td></tr><tr><td rowspan=1 colspan=1>avg.rob. acc.</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1>64.47</td><td rowspan=1 colspan=1>35.79</td><td rowspan=1 colspan=1>49.51</td><td rowspan=3 colspan=1>33.2610*4.1021.80</td><td rowspan=3 colspan=1>29.46170.301.60</td></tr><tr><td rowspan=2 colspan=1>#bestavg. diff. to bestmax diff. to best</td><td rowspan=2 colspan=3></td><td rowspan=2 colspan=1>035.3195.90</td><td rowspan=1 colspan=1>136.63</td><td rowspan=1 colspan=1>020.35</td></tr><tr><td rowspan=1 colspan=1>58.40</td><td rowspan=1 colspan=1>74.00</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=3></td><td rowspan=2 colspan=1>SF</td><td rowspan=2 colspan=1>EAD</td><td rowspan=2 colspan=1>PGD-100</td><td rowspan=2 colspan=1>FAB-10</td><td rowspan=2 colspan=1>FAB-100</td></tr><tr><td rowspan=1 colspan=1>l1-norm wo/Madry&#x27;smodel</td><td rowspan=1 colspan=3></td></tr><tr><td rowspan=4 colspan=1>avg. rob. acc.# best avg. diff. to bestmax diff. to best</td><td rowspan=1 colspan=3></td><td rowspan=1 colspan=1>58.06</td><td rowspan=1 colspan=1>32.56</td><td rowspan=1 colspan=1>43.82</td><td rowspan=1 colspan=1>33.79</td><td rowspan=4 colspan=1>32.06120.361.60</td></tr><tr><td rowspan=1 colspan=2></td><td rowspan=2 colspan=2></td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>5*</td></tr><tr><td rowspan=2 colspan=3></td><td rowspan=1 colspan=1>26.36</td><td rowspan=1 colspan=1>0.87</td><td rowspan=1 colspan=1>12.12</td><td rowspan=1 colspan=1>2.10</td></tr><tr><td rowspan=1 colspan=1>53.10</td><td rowspan=1 colspan=1>4.80</td><td rowspan=1 colspan=1>31.90</td><td rowspan=1 colspan=1>3.90</td></tr></table>
+
+In general, both average and maximum difference to best of FAB-attack are small for all the datasets and norms, implying that it does not suffer severe failures, which makes it an efficient, high quality technique to evaluate the robustness of classifiers for all $l _ { p }$ -norms. Finally, we show in Table 4 that FAB-attack outperforms or matches the competitors in 16 out of 18 cases when comparing the average $l _ { p }$ -norms of the generated adversarial perturbations.
+
+Runtime comparison: DF and SF are definitely much faster than the others as their primary goal is to find as soon as possible adversarial examples, without emphasis on minimizing their norms, while LRA is rather expensive as noted in the original paper. Below we report the runtimes (for 1000 points on MNIST and CIFAR-10, 50 on R-ImageNet) for the attacks as used in the experiments (if not specified otherwise, it includes all the restarts). For PGD and DAA this is the time for evaluating the robust accuracy at 5 thresholds, while for the other methods a single run is sufficient to compute all the statistics.
+
+MNIST: DAA-50 11736s, PGD-100 3825s for $l _ { \infty } / l _ { 2 }$ and PGD-100 14106s for $l _ { 1 }$ , CW 944s, EAD 606s, FAB-10 161s, FAB-100 1613s. CIFAR-10: DAA-50 11625s, PGD-100 31900s
+
+Table 2: As in Table 1 statistics of the performance of different attacks on Restricted ImageNet (on the first 500 points of the validation set). In total we consider 5 thresholds $\times$ 3 models = 15 cases for each of the 3 norms.
+
+statistics on Restricted ImageNet   
+
+<table><tr><td rowspan="3"></td><td colspan="4">lo-norm</td><td colspan="3"> l2-norm</td><td colspan="3">l1-norm</td></tr><tr><td>DF</td><td>DAA- 10</td><td>PGD- 10</td><td>FAB- 10</td><td>DF</td><td>PGD- 10</td><td>FAB- 10</td><td>EAD</td><td>PGD- 5</td><td>FAB- 5</td></tr><tr><td>avg.rob. acc.</td><td>35.61</td><td>38.44</td><td>26.91</td><td>27.83</td><td>45.69</td><td>31.75</td><td>33.24</td><td>71.31</td><td>40.64</td><td>38.12</td></tr><tr><td>#best</td><td>0</td><td>1</td><td>13</td><td>3</td><td>0</td><td>14</td><td>1</td><td>0</td><td>3</td><td>12</td></tr><tr><td>avg. diff. best</td><td>8.75</td><td>11.57</td><td>0.04</td><td>0.96</td><td>13.99</td><td>0.04</td><td>1.53</td><td>33.52</td><td>2.85</td><td>0.33</td></tr><tr><td>max diff. best</td><td>14.60</td><td>37.20</td><td>0.40</td><td>2.00</td><td>25.40</td><td>0.60</td><td>3.40</td><td>59.00</td><td>6.20</td><td>2.40</td></tr></table>
+
+for $l _ { \infty } / l _ { 2 }$ and 70110s for $l _ { 1 }$ , CW 3691s, EAD 3398s, FAB-10 1209s, FAB-100 12093s. RImageNet: DAA-10 6890s, PGD-10 4738s for $l _ { \infty } / l _ { 2 }$ and PGD-5 24158s for $l _ { 1 }$ , FAB-10 2268s for $l _ { \infty } / l _ { 2 }$ and FAC-5 3146s for $l _ { 1 }$ (note that different numbers of restarts/iterations for $l _ { 1 }$ are used on R-ImageNet).
+
+PGD needs a forward and a backward pass of the network for each iteration. Thus it is given 1.5 times more iterations than FAB, so that overall they have same budget of passes (we assume here that forward and backward passes take the same amount of time). In Appendix B.2 we compare PGD-1 versus FAB-1 as a function of the number of passes (2 passes are one iteration of PGD, 3 passes are one iteration of FAB - the plots show 300 passes meaning 150 iterations of PGD and 100 iterations of FAB) so that the comparison is fair concerning runtime in order to compare the performance of PGD-1 and FAB-1 as a function of runtime. If one considers just the performance up to 20 passes (10 iterations PGD, 7 iterations FAB) then FAB outperforms PGD in 18 out of 27 cases. However, one also observes that there is no general superiority of one method. For both PGD-1 and FAB-1 there are cases where the method requires the full amount of 300 passes to get to a good performance whereas the other method achieves it with significantly less iterations/passes.
+
+# 4 Conclusion
+
+In summary, our geometrically motivated FAB-attack outperforms in terms of runtime and on average in terms of quality all other high quality state-of-the-art attacks and can be used for all $p$ -norms in $p \in \{ 1 , 2 , \infty \}$ which is not the case for most other methods.
+
+# References
+
+A. Athalye, N. Carlini, and D. A. Wagner. Obfuscated gradients give a false sense of security: Circumventing defenses to adversarial examples. In ICML, 2018.   
+O. Bastani, Y. Ioannou, L. Lampropoulos, D. Vytiniotis, A. Nori, and A. Criminisi. Measuring neural net robustness with constraints. In NeurIPS, 2016.   
+W. Brendel, J. Rauber, and M. Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In ICLR, 2018.   
+T. B. Brown, D. Mané, A. Roy, M. Abadi, and J. Gilmer. Adversarial patch. In NeurIPS 2017 Workshop on Machine Learning and Computer Security, 2017.   
+N. Carlini and D. Wagner. Towards evaluating the robustness of neural networks. In IEEE Symposium on Security and Privacy, 2017a.   
+N. Carlini and D. Wagner. Adversarial examples are not easily detected: Bypassing ten detection methods. In ACM Workshop on Artificial Intelligence and Security, 2017b.   
+P. Chen, Y. Sharma, H. Zhang, J. Yi, and C. Hsieh. Ead: Elastic-net attacks to deep neural networks via adversarial examples. In AAAI, 2018.   
+F. Croce, J. Rauber, and M. Hein. Scaling up the randomized gradient-free adversarial attack reveals overestimation of robustness using established attacks. preprint, arXiv:1903.11359, 2019.   
+L. Engstrom, B. Tran, D. Tsipras, L. Schmidt, and A. Madry. A rotation and a translation suffice: Fooling CNNs with simple transformations. In NeurIPS 2017 Workshop on Machine Learning and Computer Security, 2017.   
+S. Gu and L. Rigazio. Towards deep neural network architectures robust to adversarial examples. In ICLR Workshop, 2015.   
+K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In CVPR, pp. 770–778, 2016.   
+M. Hein and M. Andriushchenko. Formal guarantees on the robustness of a classifier against adversarial manipulation. In NeurIPS, 2017.   
+R. Huang, B. Xu, D. Schuurmans, and C. Szepesvari. Learning with a strong adversary. In ICLR, 2016.   
+G. Katz, C. Barrett, D. Dill, K. Julian, and M. Kochenderfer. Reluplex: An efficient smt solver for verifying deep neural networks. In CAV, 2017.   
+A. Krizhevsky, V. Nair, and G. Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/\~kriz/cifar.html.   
+A. Kurakin, I. J. Goodfellow, and S. Bengio. Adversarial examples in the physical world. In ICLR Workshop, 2017.   
+A. Madry, A. Makelov, L. Schmidt, D. Tsipras, and A. Valdu. Towards deep learning models resistant to adversarial attacks. In ICLR, 2018.   
+A. Modas, S. Moosavi-Dezfooli, and P. Frossard. Sparsefool: a few pixels make a big difference. In CVPR, 2019.   
+S.-M. Moosavi-Dezfooli, A. Fawzi, and P. Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In CVPR, pp. 2574–2582, 2016.   
+M. Mosbach, M. Andriushchenko, T. Trost, M. Hein, and D. Klakow. Logit pairing methods can fool gradient-based attacks. In NeurIPS 2018 Workshop on Security in Machine Learning, 2018.   
+N. Narodytska and S. P. Kasiviswanathan. Simple black-box adversarial perturbations for deep networks. In CVPR 2017 Workshops, 2016.   
+N. Papernot, P. McDonald, X. Wu, S. Jha, and A. Swami. Distillation as a defense to adversarial perturbations against deep networks. In IEEE Symposium on Security & Privacy, 2016.   
+N. Papernot, N. Carlini, I. Goodfellow, R. Feinman, F. Faghri, A. Matyasko, K. Hambardzumyan, Y.-L. Juang, A. Kurakin, R. Sheatsley, A. Garg, and Y.-C. Lin. cleverhans v2.0.0: an adversarial machine learning library. preprint, arXiv:1610.00768, 2017.   
+J. Rauber, W. Brendel, and M. Bethge. Foolbox: A python toolbox to benchmark the robustness of machine learning models. In ICML Reliable Machine Learning in the Wild Workshop, 2017.   
+J. Su, D. V. Vargas, and S. Kouichi. One pixel attack for fooling deep neural networks. preprint, arXiv:1710.08864v5, 2019.   
+V. Tjeng, K. Xiao, and R. Tedrake. Evaluating robustness of neural networks with mixed integer programming. In ICLR, 2019.   
+F. Tramèr and D. Boneh. Adversarial training and robustness for multiple perturbations. preprint, arXiv:1904.13000, 2019.   
+D. Tsipras, S. Santurkar, L. Engstrom, A. Turner, and A. Madry. Robustness may be at odds with accuracy. In ICLR, 2019.   
+E. Wong, F. R. Schmidt, and J. Z. Kolter. Wasserstein adversarial examples via projected sinkhorn iterations. preprint, arXiv:1902.07906.   
+S. Zheng, Y. Song, T. Leung, and I. J. Goodfellow. Improving the robustness of deep neural networks via stability training. In CVPR, 2016.   
+T. Zheng, C. Chen, and K. Ren. Distributionally adversarial attack. In AAAI, 2019.
+
+# A Experiments
+
+# A.1 Models
+
+The plain and $l _ { \infty }$ -AT models on MNIST are those available at https://github.com/ MadryLab/mnist_challenge and consist of two convolutional and two fully-connected layers. The architecture of the CIFAR-10 models has 8 convolutional layers (with number of filters increasing from 96 to 384) and 2 dense layers, while on Restricted ImageNet we use the models (ResNet-50 He et al. (2016)) from Tsipras et al. (2019) and available at https://github.com/MadryLab/robust-features-code.
+
+The models on MNIST achieve the following clean accuracy: plain $9 8 . 7 \%$ , $l _ { \infty }$ -AT $9 8 . 5 \%$ , $l _ { 2 }$ -AT $9 8 . 6 \%$ . The models on CIFAR-10 achieve the following clean accuracy: plain $8 9 . 2 \%$ , $l _ { \infty }$ -AT $7 9 . 4 \%$ , $l _ { 2 }$ -AT $8 1 . 2 \%$ .
+
+# A.2 Attacks
+
+We use CW with 10000 iterations and confidence 0, EAD with 1000 iterations, $l _ { 1 }$ decision rule and $\beta \ : = \ : 0 . 0 5$ . In both cases we set the parameters to achieve minimally (wrt $l _ { 2 }$ for CW and $l _ { 1 }$ for EAD) distorted adversarial examples. We could not use these methods on Restricted ImageNet since, to be compatible with the attack from Papernot et al. (2017), it would be necessary to reimplement from scratch the models of Tsipras et al. (2019), as done in https://github.com/tensorflow/cleverhans/tree/master/ cleverhans/model_zoo/madry_lab_challenges for a similar situation.
+
+For DAA we use 200 iterations for MNIST, 50 for the other datasets and, given a threshold , a step size of $\epsilon / 3 0$ for MNIST, $\epsilon / 1 0$ otherwise.
+
+We perform PGD with 150 iterations, except for the case of $l _ { 1 }$ on Restricted ImageNet where we use 450 iterations. For PGD wrt ${ \mathit { l } } _ { \infty }$ we use, given a threshold $\epsilon$ , a step size of $\epsilon / 1 0$ in the direction of the sign of the gradient of the cross entropy loss, for PGD wrt $l _ { 2 }$ we perform at each iteration a step in the direction of the gradient of size $\epsilon / 4$ , for PGD wrt $l _ { 1 }$ we use the gradient step suggested in Tramèr & Boneh (2019) (with sparsity levels of $1 \%$ for MNIST and $1 0 \%$ for CIFAR-10 and Restricted ImageNet), with size $\epsilon / 2$ . The above stepsize parameters $\epsilon / { } _ { 4 }$ for $l _ { 2 }$ and $\epsilon / 1 0$ for $l _ { \infty }$ for PGD were obtained, by doing a grid search for each norm separately and using the values working best on average on MNIST and CIFAR-10. In Appendix we discuss the influence of the step-size and show that our chosen values perform best on average, see Figure 3.
+
+For FAB-attack we set 100 iterations, except for the case of $l _ { 1 }$ on Restricted ImageNet where we use 300 iterations. Moreover, we use the following parameters for all the cases on MNIST and CIFAR-10: $\alpha _ { \mathrm { m a x } } = 0 . 1$ , $\eta = 1 . 0 5$ , $\beta = 0 . 9$ . On Restricted ImageNet we set $\alpha _ { \mathrm { m a x } } = 0 . 0 5$ , $\eta = 1 . 3$ , $\beta = 0 . 9$ . When using random restarts, FAB-attack needs a value for the parameters $\epsilon$ . It represents the radius of the $l _ { p }$ -ball around the original point inside which we sample the starting point of the algorithm, at least until a sufficiently small adversarial perturbation is found (see Algorithm 1). We use the values of $\epsilon$ reported in Table 3. Note however that the attack usually finds at the first run an adversarial perturbation small enough so that $\epsilon$ in practice rarely comes into play.
+
+Table 3: We report the values of $\epsilon$ used for sampling in case our FAB-attack uses random restarts.
+
+values of $\epsilon$ used for random restarts   
+
+<table><tr><td></td><td colspan="3">MNIST</td><td colspan="3">CIFAR-10</td><td colspan="3">Restricted ImageNet</td></tr><tr><td></td><td>plain</td><td>lo-AT</td><td>l2-AT</td><td>plain</td><td>lo-AT</td><td>l2-AT</td><td>plain</td><td>loo-AT</td><td>l2-AT</td></tr><tr><td>1</td><td>0.15</td><td>0.3</td><td>0.3</td><td>0.0</td><td>0.02</td><td>0.02</td><td>0.02</td><td>0.08</td><td>0.08</td></tr><tr><td>12</td><td>2.0</td><td>2.0</td><td>2.0</td><td>0.5</td><td>4.0</td><td>4.0</td><td>5.0</td><td>5.0</td><td>5.0</td></tr><tr><td>l</td><td>40.0</td><td>40.0</td><td>40.0</td><td>10.0</td><td>10.0</td><td>10.0</td><td>100.0</td><td>250.0</td><td>250.0</td></tr></table>
+
+# A.3 Complete results
+
+In Tables 5 to 13 we report the complete values of the robust accuracy, wrt either ${ \mathit { l } } _ { \infty }$ , $l _ { 2 }$ or $l _ { 1 }$ , computed by every attack, for 3 datasets, 3 models for each dataset, 5 thresholds for each model (135 evaluations overall).
+
+# A.4 Further results
+
+In Table 4 we report the average $l _ { p }$ -norm of the adversarial perturbations found by the different attacks, computed on the originally correctly classified points on which the attack is successful. Note that we cannot show this statistic for the attacks which do not minimize the distance of the adversarial example to the clean input (PGD and DAA). FAB-attack produces also in this metric the best results in most of the cases, being the best for every model when considering ${ \mathit { l } } _ { \infty }$ and $l _ { 2 }$ , and the best in 4 out of 6 cases in $l _ { 1 }$ (lower values mean a stronger attack).
+
+Table 4: We report mean $l _ { p }$ -norm of the adversarial perturbations found by the attacks (when successful, excluding the already misclassified points) for every model.   
+average norm of adversarial perturbations   
+
+<table><tr><td>lo-norm</td><td></td><td></td><td>DF</td><td>FAB</td></tr><tr><td rowspan="3">MNIST</td><td>plain</td><td rowspan="3"></td><td>0.078</td><td>0.066</td></tr><tr><td>lo-at</td><td>0.508</td><td>0.326</td></tr><tr><td>l2-at</td><td>0.249 0.008</td><td>0.170</td></tr><tr><td rowspan="3">CIFAR-10</td><td>plain lo-at</td><td colspan="2">0.032</td><td>0.006</td></tr><tr><td>l2-at</td><td colspan="2"></td><td>0.024</td></tr><tr><td></td><td></td><td>0.026</td><td>0.019</td></tr><tr><td> l2-norm</td><td colspan="4">DF CW</td></tr><tr><td rowspan="3">MNIST</td><td>plain</td><td>1.13 1.01</td><td>LRA</td><td>FAB</td></tr><tr><td></td><td>1.76</td><td>1.00</td><td>1.00</td></tr><tr><td>loo-at l2-at</td><td>4.95 3.10 2.35</td><td>1.25</td><td>1.12</td></tr><tr><td rowspan="3">CIFAR-10</td><td>plain</td><td>0.28 0.21</td><td>2.25</td><td>2.24</td></tr><tr><td>loo-at</td><td>0.96 0.74</td><td>0.22</td><td>0.21</td></tr><tr><td>l2-at</td><td>0.91 0.71</td><td>0.74</td><td>0.73</td></tr><tr><td></td><td></td><td></td><td>0.72</td><td>0.70</td></tr><tr><td> l1-norm</td><td></td><td colspan="2">EAD</td><td>FAB</td></tr><tr><td rowspan="3">MNIST</td><td>plain</td><td colspan="2">6.38</td><td>6.04</td></tr><tr><td>lo-at</td><td colspan="2">8.26</td><td>3.36</td></tr><tr><td>l2-at</td><td colspan="2">12.18</td><td>12.16</td></tr><tr><td rowspan="3">CIFAR-10</td><td>plain</td><td colspan="2"></td><td>2.87</td></tr><tr><td>loo-at</td><td></td><td>3.01 5.79</td><td>6.03</td></tr><tr><td>l2-at</td><td colspan="2">7.94</td><td>8.05</td></tr><tr><td></td><td></td><td colspan="2"></td><td></td></tr></table>
+
+Table 5: Comparison of $l _ { \infty }$ -, $l _ { 2 }$ - and $l _ { 1 }$ -attacks on a naturally trained model on MNIST. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 1000 points on the test set for ${ \mathit { l } } _ { \infty }$ and $l _ { 1 }$ , on 500 points for $l _ { 2 }$ .
+
+Robust accuracy of MNIST plain model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 50</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">18</td><td>0.03 0.05</td><td>93.2</td><td>91.9</td><td>91.9</td><td>92.0</td><td>91.9</td><td>91.9</td><td>92.0</td><td>92.0</td><td>92.0</td></tr><tr><td></td><td>83.4</td><td>78.2</td><td>76.7</td><td>76.0</td><td>74.9</td><td>74.6</td><td>77.2</td><td>76.8</td><td>76.1</td></tr><tr><td>0.07</td><td>61.5</td><td>59.8</td><td>56.3</td><td>43.8</td><td>41.8</td><td>40.4</td><td>44.3</td><td>43.1</td><td>42.6</td></tr><tr><td>0.09</td><td>33.2</td><td>46.7</td><td>41.0</td><td>16.5</td><td>14.2</td><td>12.8</td><td>16.2</td><td>14.8</td><td>14.4</td></tr><tr><td>0.11</td><td>13.1</td><td>34.4</td><td>26.2</td><td>4.0</td><td>2.8</td><td>2.4</td><td>3.3</td><td>3.1</td><td>2.4</td></tr><tr><td></td><td></td><td>CW</td><td>DF</td><td>LRA</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">12</td><td>0.5</td><td>92.6</td><td>93.6</td><td>92.6</td><td>92.6</td><td>92.6</td><td>92.6</td><td>92.6</td><td>92.6</td><td>92.6</td></tr><tr><td>1</td><td>47.4</td><td>58.6</td><td>47.4</td><td>48.4</td><td>47.4</td><td>46.2</td><td>47.0</td><td>46.8</td><td>46.2</td></tr><tr><td>1.5</td><td>8.8</td><td>19.8</td><td>7.8</td><td>9.8</td><td>8.8</td><td>8.2</td><td>7.8</td><td>7.2</td><td>7.0</td></tr><tr><td>2</td><td>0.6</td><td>1.8</td><td>0.2</td><td>1.2</td><td>0.6</td><td>0.6</td><td>0.2</td><td>0.2</td><td>0.2</td></tr><tr><td>2.5</td><td>0.0</td><td>0.0</td><td>0.0</td><td>0.6</td><td>0.2</td><td>0.2</td><td>0.0</td><td>0.0</td><td>0.0</td></tr><tr><td colspan="2"></td><td colspan="2">SparseFool</td><td>EAD</td><td>PGD-</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td><td>FAB-</td></tr><tr><td rowspan="5">l</td><td></td><td colspan="2"></td><td></td><td>1</td><td>10</td><td>100</td><td>1</td><td>10</td><td>100</td></tr><tr><td>2 4</td><td colspan="2">95.5</td><td>93.6 76.7</td><td>94.4</td><td>93.9</td><td>93.7</td><td>94.2</td><td>93.7</td><td>93.5</td></tr><tr><td>6</td><td colspan="2">88.9 75.8</td><td>48.1</td><td>79.8</td><td>77.5</td><td>76.9</td><td>80.2</td><td>76.6</td><td>75.2</td></tr><tr><td></td><td colspan="2"></td><td></td><td>57.4</td><td>52.2 36.3</td><td>49.3</td><td>54.5</td><td>47.2</td><td>43.3</td></tr><tr><td>8 10</td><td colspan="2">60.3 43.8</td><td>26.6 11.2</td><td>46.7 40.0</td><td>27.4</td><td>31.6 22.1</td><td>31.3 15.2</td><td>25.3 9.8</td><td>22.4 8.4</td></tr></table>
+
+Table 6: Comparison of ${ \mathit { l } } _ { \infty }$ -, $l _ { 2 }$ - and $l _ { 1 }$ -attacks on an $l _ { \infty }$ -robust model on MNIST. We report the accuracy on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 1000 points on the test set for $l _ { \infty }$ and $l _ { 1 }$ , on 500 points for $l _ { 2 }$ .
+
+Robust accuracy of MNIST $l _ { \infty }$ -robust model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 50</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">1</td><td>0.2 0.25</td><td>95.2 94.7</td><td>94.6 92.7</td><td>93.7 91.1</td><td>95.0 93.1</td><td>94.2 91.8</td><td>93.7 91.4</td><td>94.6</td><td>94.4</td><td>93.9</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>93.3</td><td>92.1</td><td>91.7</td></tr><tr><td>0.3</td><td>93.9</td><td>89.5</td><td>87.2</td><td>91.3</td><td>88.3</td><td>87.6</td><td>91.2</td><td>89.2</td><td>88.5</td></tr><tr><td>0.325</td><td>92.5</td><td>72.1</td><td>64.2</td><td>74.9</td><td>68.4</td><td>64.7</td><td>86.2</td><td>83.1</td><td>81.3</td></tr><tr><td>0.35</td><td>89.8</td><td>19.7</td><td>11.7</td><td>32.1</td><td>19.3</td><td>13.8</td><td>48.7</td><td>32.0</td><td>23.8</td></tr><tr><td colspan="9"></td></tr><tr><td rowspan="5"></td><td></td><td>CW</td><td>DF</td><td>LRA</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td>1</td><td>88.8</td><td>94.6</td><td>73.6</td><td>92.2</td><td>90.8</td><td>89.8</td><td>84.2</td><td>70.6</td><td>65.4</td></tr><tr><td>1.5</td><td>77.6</td><td>93.0</td><td>25.8</td><td>86.0</td><td>81.2</td><td>77.0</td><td>47.0</td><td>20.6</td><td>12.2</td></tr><tr><td>2</td><td>64.4</td><td>91.6</td><td>3.2</td><td>77.8</td><td>67.0</td><td>57.8</td><td>15.6</td><td>1.8</td><td>0.2</td></tr><tr><td>2.5 3</td><td>53.8 46.8</td><td>89.6 84.6</td><td>0.4</td><td>68.2</td><td>49.6</td><td>36.4</td><td>3.8</td><td>0.0</td><td>0.0</td></tr><tr><td colspan="9"></td></tr><tr><td rowspan="5"></td><td></td><td rowspan="5">SparseFool</td><td></td><td>0.0</td><td>59.8</td><td>29.6</td><td>13.4</td><td>1.4</td><td>0.0</td><td>0.0</td></tr><tr><td></td><td></td><td>EAD</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td>2.5</td><td>96.8</td><td>92.2</td><td>94.1</td><td>93.7</td><td>93.6</td><td>90.1</td><td>74.3</td><td>56.9</td></tr><tr><td>5</td><td>96.5</td><td>76.0</td><td>90.9 85.2</td><td>88.9 81.4</td><td>88.2 79.0</td><td>85.8 82.6</td><td>39.4 19.8</td><td>17.6 5.0</td></tr><tr><td>7.5 10</td><td colspan="2">96.4 96.4</td><td>49.5 27.4</td><td>80.2</td><td>73.5</td><td>70.3</td><td>78.4</td><td>11.9</td></tr></table>
+
+Table 7: Comparison of ${ \mathit { l } } _ { \infty }$ -, $l _ { 2 }$ - and $l _ { 1 }$ -attacks on an $l _ { 2 }$ -robust model on MNIST. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 1000 points on the test set for ${ \mathit { l } } _ { \infty }$ and $l _ { 1 }$ , on 500 points for $l _ { 2 }$ .
+
+Robust accuracy of MNIST $l _ { 2 }$ -robust model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 50</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">18</td><td>0.05 0.1</td><td>96.7</td><td>96.4</td><td>96.3</td><td>96.4</td><td>96.3</td><td>96.3</td><td>96.4</td><td>96.3</td><td>96.3</td></tr><tr><td></td><td>93.4</td><td>91.0</td><td>90.2</td><td>90.7</td><td>90.4</td><td>90.2</td><td>90.8</td><td>90.4</td><td>90.4</td></tr><tr><td>0.15</td><td>86.4</td><td>74.3</td><td>72.3</td><td>74.6</td><td>73.2</td><td>72.4</td><td>74.0</td><td>72.3</td><td>72.0</td></tr><tr><td>0.2</td><td>73.8</td><td>34.5</td><td>27.2</td><td>36.2</td><td>29.8</td><td>26.5</td><td>34.1</td><td>28.2</td><td>24.4</td></tr><tr><td>0.25</td><td>55.1</td><td>1.5</td><td>0.9</td><td>2.6</td><td>1.5</td><td>1.0</td><td>1.9</td><td>0.9</td><td>0.8</td></tr><tr><td colspan="9"></td></tr><tr><td rowspan="5"></td><td></td><td>CW</td><td>DF</td><td>LRA</td><td>PGD-</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB-</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td>1</td><td>92.6</td><td>93.8</td><td>92.6</td><td>1 93.0</td><td>93.0</td><td>93.0</td><td>1 92.6</td><td>92.6</td><td>92.6</td></tr><tr><td>1.5</td><td>84.8</td><td>87.2</td><td>83.4</td><td>83.8</td><td>83.4</td><td>83.4</td><td>83.8</td><td>83.6</td><td>83.6</td></tr><tr><td>2</td><td>70.6</td><td>79.0</td><td>68.0</td><td>68.8</td><td>68.0</td><td>67.6</td><td>69.8</td><td>69.0</td><td>67.8</td></tr><tr><td>2.5 3</td><td>46.4 17.2</td><td>67.4 54.2</td><td>41.6</td><td>45.6</td><td>40.4</td><td>37.6</td><td>45.6</td><td>41.8</td><td>39.2 11.0</td></tr><tr><td colspan="9"></td></tr><tr><td colspan="2"></td><td colspan="2">SparseFool</td><td>11.2 EAD</td><td>17.4 PGD-</td><td>12.4 PGD-</td><td>10.2 PGD-</td><td>18.6 FAB-</td><td>13.4 FAB-</td><td>FAB-</td></tr><tr><td rowspan="5"></td><td colspan="10"></td></tr><tr><td>5</td><td colspan="2">94.9</td><td>89.8</td><td>1 90.3</td><td>10 90.2</td><td>100 90.2</td><td>1 90.5</td><td>10 90.2</td><td>100 90.0</td></tr><tr><td>8.75</td><td colspan="2">89.1</td><td>71.2</td><td>75.5</td><td>74.0</td><td>72.7</td><td>75.3</td><td>73.7</td><td>72.2</td></tr><tr><td>12.5</td><td colspan="2">81.0</td><td>45.9</td><td>61.1</td><td>57.5</td><td>54.9</td><td>55.6</td><td>49.2</td><td>45.7</td></tr><tr><td>16.25 20</td><td colspan="2">72.8 60.8</td><td>20.6 8.3</td><td>49.2 41.4</td><td>42.3 29.6</td><td>38.4 23.2</td><td>32.2 15.2</td><td>24.1 9.4</td><td>20.8 7.7</td></tr></table>
+
+Table 8: Comparison of $l _ { \infty } .$ -, $l _ { 2 ^ { - } }$ and $l _ { 1 } .$ -attacks on a naturally trained model on CIFAR-10. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 1000 points on the test set for $l _ { \infty }$ and $l _ { 1 }$ , on 500 points for $l _ { 2 }$ .
+
+Robust accuracy of CIFAR-10 plain model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 50</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">18</td><td rowspan="5">1/255 1.5/255 2/255</td><td>62.6</td><td>65.7</td><td>64.1</td><td>56.1</td><td>55.8</td><td>55.6</td><td>56.5</td><td>55.9</td><td>55.7</td></tr><tr><td>49.3</td><td>63.2</td><td>60.8</td><td>38.9</td><td>37.9</td><td>37.4</td><td>38.5</td><td>37.7</td><td>37.4</td></tr><tr><td>37.3</td><td>62.4</td><td>58.5</td><td>24.3</td><td>23.3</td><td>22.9</td><td>23.4</td><td>21.9</td><td>21.2</td></tr><tr><td>26.4</td><td>61.2</td><td>56.3</td><td>16.2</td><td>14.8</td><td>14.0</td><td>13.2</td><td>12.0</td><td>11.8</td></tr><tr><td>19.0</td><td>60.2</td><td>54.4</td><td>10.7</td><td>9.2</td><td>8.6</td><td>7.4</td><td>5.8</td><td>5.4</td></tr><tr><td rowspan="2"></td><td></td><td>CW</td><td>DF</td><td>LRA</td><td>PGD-</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td><td>FAB-</td></tr><tr><td>0.1</td><td>69.4</td><td>72.2</td><td>69.0</td><td>1 68.4</td><td>10 67.6</td><td>100 67.6</td><td>1 68.4</td><td>10 68.4</td><td>100 68.4</td></tr><tr><td rowspan="4">l2</td><td>0.15</td><td>55.4</td><td>62.6</td><td>55.0</td><td>54.6</td><td>53.8</td><td>53.8</td><td>54.6</td><td>54.0</td><td>53.8</td></tr><tr><td>0.2</td><td>43.4</td><td>51.2</td><td>43.4</td><td>43.8</td><td>42.8</td><td>42.0</td><td>42.4</td><td>42.0</td><td>41.8</td></tr><tr><td>0.3</td><td>21.6</td><td>33.8</td><td>22.0</td><td>24.8</td><td>24.2</td><td>23.6</td><td>21.6</td><td>20.8</td><td>20.6</td></tr><tr><td>0.4</td><td>9.4</td><td>20.8</td><td>9.8</td><td>18.2</td><td>16.2</td><td>15.4</td><td>9.6</td><td>8.2</td><td>8.0</td></tr><tr><td rowspan="2"></td><td></td><td colspan="2">SparseFool</td><td>EAD</td><td>PGD-</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td><td>FAB-</td></tr><tr><td></td><td colspan="2"></td><td></td><td>1</td><td>10</td><td>100</td><td>1</td><td>10</td><td>100</td></tr><tr><td rowspan="4">l</td><td>2 4</td><td colspan="2">72.1</td><td>54.7</td><td>54.9</td><td>54.4</td><td>53.9</td><td>55.5</td><td>52.2</td><td>50.8</td></tr><tr><td></td><td colspan="2">58.6 45.6</td><td>24.1</td><td>30.0</td><td>29.1</td><td>28.9</td><td>30.7</td><td>25.1</td><td>22.4</td></tr><tr><td>6</td><td colspan="2"></td><td>8.9</td><td>18.8</td><td>18.6</td><td>18.4</td><td>17.0</td><td>10.5</td><td>8.1</td></tr><tr><td>8 10</td><td colspan="2">34.3 27.2</td><td>3.0 0.7</td><td>14.2 12.9</td><td>14.1 12.5</td><td>14.0 12.3</td><td>7.8 4.7</td><td>3.8 1.5</td><td>2.5 1.0</td></tr></table>
+
+Table 9: Comparison of $l _ { \infty }$ -, $l _ { 2 }$ - and $l _ { 1 }$ -attacks on an ${ \mathit { l } } _ { \infty }$ -robust model on CIFAR-10. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 1000 points on the test set for ${ \mathit { l } } _ { \infty }$ and $l _ { 1 }$ , on 500 points for $l _ { 2 }$ .
+
+Robust accuracy of CIFAR-10 $l _ { \infty }$ -robust model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 50</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">18</td><td>2/255 4/255</td><td>66.8</td><td>66.9</td><td>66.3</td><td>65.5</td><td>65.5</td><td>65.5</td><td>65.8</td><td>65.8</td><td>65.7</td></tr><tr><td></td><td>53.2</td><td>63.8</td><td>61.4</td><td>49.8</td><td>49.3</td><td>49.0</td><td>49.2</td><td>49.1</td><td>48.9</td></tr><tr><td>6/255</td><td>42.9</td><td>63.1</td><td>58.4</td><td>38.0</td><td>36.9</td><td>36.6</td><td>35.4</td><td>34.7</td><td>34.6</td></tr><tr><td>8/255</td><td>32.9</td><td>61.2</td><td>56.3</td><td>30.5</td><td>30.0</td><td>29.6</td><td>23.8</td><td>23.5</td><td>23.3</td></tr><tr><td>10/255</td><td>24.5</td><td>59.8</td><td>54.1</td><td>25.8</td><td>23.7</td><td>22.4</td><td>15.4</td><td>14.7</td><td>14.4</td></tr><tr><td></td><td></td><td>CW</td><td>DF</td><td>LRA</td><td>PGD-</td><td>PGD-</td><td>PGD- 100</td><td>FAB-</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">12</td><td>0.25</td><td>64.6</td><td>67.0</td><td>64.4</td><td>1 64.4</td><td>10 64.4</td><td>64.4</td><td>1 64.8</td><td>64.6</td><td>64.4</td></tr><tr><td>0.5</td><td>48.4</td><td>53.0</td><td>48.8</td><td></td><td></td><td>48.0</td><td></td><td>48.4</td><td>48.2</td></tr><tr><td>0.75</td><td>33.4</td><td>41.4</td><td>33.4</td><td>49.0</td><td>48.4 38.2</td><td></td><td>48.4</td><td>33.2</td><td>33.0</td></tr><tr><td>1</td><td>22.8</td><td></td><td></td><td>39.0</td><td></td><td>37.4</td><td>33.6</td><td></td><td>21.4</td></tr><tr><td>1.25</td><td>12.0</td><td>32.6 24.2</td><td>22.8 13.0</td><td>35.0 34.6</td><td>34.4 34.2</td><td>33.8 33.2</td><td>22.2 12.2</td><td>21.6 11.2</td><td>11.2</td></tr><tr><td colspan="2"></td><td colspan="2">SparseFool</td><td>EAD</td><td>PGD-</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td><td>FAB-</td></tr><tr><td rowspan="5">l</td><td></td><td colspan="2"></td><td></td><td>1</td><td>10</td><td>100</td><td>1</td><td>10</td><td>100</td></tr><tr><td>5 8.75</td><td colspan="2">57.8</td><td>36.8</td><td>47.3</td><td>46.6</td><td>46.2</td><td>43.1</td><td>39.9</td><td>37.9</td></tr><tr><td>12.5</td><td colspan="2">44.7 34.9</td><td>19.2</td><td>37.4</td><td>37.0</td><td>36.8</td><td>25.7</td><td>22.5</td><td>20.2</td></tr><tr><td></td><td colspan="2"></td><td>7.1</td><td>34.0</td><td>33.9</td><td>33.9</td><td>13.7</td><td>10.9</td><td>8.7</td></tr><tr><td>16.25 20</td><td colspan="2">27.6 20.2</td><td>3.0 0.9</td><td>33.3 32.9</td><td>33.2 32.8</td><td>33.1 32.8</td><td>7.1 3.8</td><td>4.3 1.7</td><td>3.5 1.3</td></tr></table>
+
+Table 10: Comparison of $l _ { \infty } -$ , $l _ { 2 ^ { - } }$ and $l _ { 1 }$ -attacks on an $l _ { 2 }$ -robust model on CIFAR-10. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 1000 points on the test set for $l _ { \infty }$ and $l _ { 1 }$ , on 500 points for $l _ { 2 }$ .
+
+Robust accuracy of CIFAR-10 $l _ { 2 }$ -robust model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 50</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td rowspan="5">18</td><td>2/255 4/255</td><td>64.1</td><td>67.2</td><td>66.3</td><td>62.6</td><td>62.5</td><td>62.4</td><td>62.7</td><td>62.6</td><td>62.6</td></tr><tr><td></td><td>49.0</td><td>65.0</td><td>62.8</td><td>45.3</td><td>45.0</td><td>44.9</td><td>44.4</td><td>44.2</td><td>44.2</td></tr><tr><td>6/255</td><td>36.9</td><td>64.2</td><td>60.8</td><td>32.9</td><td>31.6</td><td>31.1</td><td>27.2</td><td>26.8</td><td>26.7</td></tr><tr><td>8/255</td><td>25.8</td><td>62.3</td><td>58.0</td><td>25.7</td><td>24.9</td><td>23.9</td><td>14.8</td><td>14.1</td><td>13.8</td></tr><tr><td>10/255</td><td>17.6</td><td>61.9</td><td>54.8</td><td>21.9</td><td>19.8</td><td>18.6</td><td>8.6</td><td>8.0</td><td>7.9</td></tr><tr><td colspan="9"></td><td></td></tr><tr><td rowspan="5">l2</td><td></td><td>CW</td><td>DF</td><td>LRA</td><td>PGD- 1</td><td>PGD- 10</td><td>PGD- 100</td><td>FAB- 1</td><td>FAB- 10</td><td>FAB- 100</td></tr><tr><td>0.25</td><td>66.0</td><td>67.0</td><td>65.6</td><td>65.8</td><td>65.6</td><td>65.6</td><td>65.6</td><td>65.6</td><td>65.6</td></tr><tr><td>0.5</td><td>48.2</td><td>53.8</td><td>47.8</td><td>49.6</td><td>48.8</td><td>48.8</td><td>48.4</td><td>48.2</td><td>48.0</td></tr><tr><td>0.75</td><td>32.6</td><td>42.2</td><td>32.4</td><td>38.4</td><td>37.2</td><td>36.4</td><td>32.8</td><td>32.4</td><td>32.2</td></tr><tr><td>1 1.25</td><td>21.6 11.4</td><td>30.0</td><td>21.6</td><td>35.4</td><td>33.6</td><td>33.0</td><td>21.8</td><td>21.4</td><td>21.0</td></tr><tr><td colspan="9"></td></tr><tr><td rowspan="5"></td><td></td><td rowspan="5"></td><td>22.4</td><td>12.4</td><td>34.2</td><td>31.6</td><td>31.2</td><td>12.2</td><td>12.2</td><td>11.4</td></tr><tr><td></td><td>SparseFool</td><td>EAD</td><td>PGD- 1</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td><td>FAB-</td></tr><tr><td>3</td><td>69.5</td><td>62.2</td><td>64.5</td><td>10 64.4</td><td>100 64.4</td><td>1 63.4</td><td>10 63.2</td><td>100 63.0</td></tr><tr><td>6</td><td>61.6</td><td>45.5</td><td>51.9</td><td>51.9</td><td>51.8</td><td>48.6</td><td>47.2</td><td>45.6</td></tr><tr><td>9</td><td colspan="2">53.1</td><td>27.7</td><td>42.8</td><td></td><td></td><td></td><td></td></tr><tr><td rowspan="3">l1</td><td rowspan="2">12</td><td colspan="2"></td><td>17.9</td><td>38.5</td><td>42.5</td><td>42.5 38.0</td><td>33.9</td><td>30.6</td><td>28.8</td></tr><tr><td></td><td>44.4 37.0</td><td>10.4</td><td>35.8</td><td>38.3 35.8</td><td></td><td>23.8</td><td>19.8</td><td>17.3</td></tr><tr><td>15</td><td colspan="2"></td><td></td><td></td><td></td><td>35.4</td><td>16.0</td><td>12.4</td><td>11.2</td></tr></table>
+
+Table 11: Comparison of ${ \mathit { l } } _ { \infty }$ -, $l _ { 2 }$ - and $l _ { 1 }$ -attacks on a naturally trained model on Restricted ImageNet. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 500 points of the test set.
+
+Robust accuracy of Restricted ImageNet plain model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 10</td><td>PGD- 1</td><td>PGD- 10</td><td>FAB- 1</td><td>FAB- 10</td></tr><tr><td rowspan="5">1</td><td>0.25/ /255 0.5/255</td><td>76.6 52.0</td><td>74.8 51.8</td><td>74.8 48.2</td><td>74.8 38.2</td><td>74.6 37.8</td><td>75.2 39.6</td><td>75.2 39.6</td></tr><tr><td>0.75/255</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>26.8</td><td>46.0</td><td>41.0</td><td>12.2</td><td>12.2</td><td>14.2</td><td>14.2</td></tr><tr><td>1/255</td><td>11.2</td><td>43.2</td><td>39.4</td><td>3.8</td><td>3.8</td><td>3.6</td><td>3.6</td></tr><tr><td>1.25/255</td><td>5.0</td><td>41.2</td><td>38.2</td><td>1.0</td><td>1.0</td><td>1.2</td><td>1.0</td></tr><tr><td></td><td></td><td></td><td></td><td>DF</td><td>PGD- 1</td><td>PGD-</td><td>FAB-</td><td>FAB-</td></tr><tr><td rowspan="5">l2</td><td>0.2</td><td></td><td></td><td></td><td></td><td>10</td><td>1</td><td>10</td></tr><tr><td>0.4</td><td></td><td></td><td>80.2 58.4</td><td>76.0</td><td>76.0</td><td>77.0</td><td>76.8</td></tr><tr><td>0.6</td><td></td><td></td><td>33.8</td><td>40.8 15.4</td><td>40.6 14.8</td><td>43.0 19.0</td><td>42.2 18.2</td></tr><tr><td>0.8</td><td></td><td></td><td></td><td>4.0</td><td>4.0</td><td></td><td></td></tr><tr><td>1</td><td></td><td></td><td>18.8 8.6</td><td>1.6</td><td>1.6</td><td>4.6 1.2</td><td>4.4 1.0</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td rowspan="5">1</td><td></td><td></td><td>SparseFool</td><td>PGD-</td><td>1</td><td>PGD- 5</td><td>FAB- 1</td><td>FAB- 5</td></tr><tr><td>5</td><td></td><td></td><td>88.6</td><td>81.8</td><td>81.8</td><td>79.6</td><td>78.0</td></tr><tr><td>16</td><td></td><td></td><td>80.0</td><td>45.2</td><td>45.2</td><td>46.8</td><td>40.0</td></tr><tr><td>27</td><td></td><td></td><td>70.6</td><td>17.8</td><td>17.4</td><td>25.6</td><td>19.8</td></tr><tr><td>38 49</td><td></td><td></td><td>65.0 55.4</td><td>6.2 2.2</td><td>6.0 2.2</td><td>13.6 6.8</td><td>7.0 3.8</td></tr></table>
+
+Table 12: Comparison of $l _ { \infty }$ -, $l _ { 2 ^ { - } }$ and $l _ { 1 }$ -attacks on an $l _ { \infty }$ -robust model on Restricted ImageNet. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 500 points of the test set.
+
+Robust accuracy of Restricted ImageNet $l _ { \infty }$ -robust model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 10</td><td>PGD- 1</td><td>PGD- 10</td><td>FAB- 1</td><td>FAB- 10</td></tr><tr><td rowspan="5">18</td><td>2/255</td><td>75.8</td><td>75.0</td><td>75.0</td><td>74.6</td><td>74.6</td><td>75.2</td><td>75.2</td></tr><tr><td>4/255</td><td>53.0</td><td>46.2</td><td>46.2</td><td>45.4</td><td>45.4</td><td>47.4</td><td>47.4</td></tr><tr><td>6/255</td><td>32.4</td><td>24.6</td><td>23.8</td><td>19.4</td><td>19.4</td><td>21.2</td><td>21.0</td></tr><tr><td>8/255</td><td>19.4</td><td>17.0</td><td>14.6</td><td>6.2</td><td>6.2</td><td>6.8</td><td>6.8</td></tr><tr><td>10/255</td><td>10.8</td><td>12.8</td><td>11.6</td><td>1.0</td><td>0.8</td><td>1.2</td><td>1.2</td></tr><tr><td></td><td></td><td></td><td></td><td>DF</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td></tr><tr><td rowspan="5">l2</td><td>1</td><td></td><td></td><td>79.4</td><td>1 76.6</td><td>10 76.6</td><td>1 77.0</td><td>10 76.8</td></tr><tr><td>2</td><td></td><td></td><td>65.0</td><td>46.8</td><td>46.2</td><td>49.8</td><td>49.2</td></tr><tr><td>3</td><td></td><td></td><td>46.8</td><td>22.4</td><td>21.4</td><td>24.4</td><td>23.8</td></tr><tr><td>4</td><td></td><td></td><td>32.8</td><td>9.0</td><td>8.6</td><td>10.8</td><td>10.6</td></tr><tr><td>5</td><td></td><td></td><td>20.4</td><td>3.0</td><td>2.8</td><td>3.2</td><td>3.2</td></tr><tr><td></td><td></td><td></td><td>SparseFool</td><td></td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td></tr><tr><td rowspan="5">l</td><td></td><td></td><td></td><td></td><td>1</td><td>5</td><td>1</td><td>5</td></tr><tr><td>15</td><td></td><td></td><td>81.8</td><td>69.8</td><td>69.8</td><td>69.6</td><td>68.2</td></tr><tr><td>25</td><td></td><td></td><td>76.4</td><td>58.6</td><td>58.2</td><td>56.2</td><td>53.6</td></tr><tr><td>40</td><td></td><td></td><td>71.4</td><td>41.0</td><td>41.0</td><td>41.2</td><td>37.6</td></tr><tr><td>60 100</td><td></td><td></td><td>63.2 49.2</td><td>28.8 12.0</td><td>28.8 11.6</td><td>28.2 14.6</td><td>23.8 11.2</td></tr></table>
+
+Table 13: Comparison of ${ \mathit { l } } _ { \infty }$ -, $l _ { 2 }$ - and $l _ { 1 }$ -attacks on an $l _ { 2 }$ -robust model on Restricted ImageNet. We report the accuracy in percentage of the classifier on the test set if the attack is allowed to perturb the test points of $\epsilon$ in $l _ { p }$ -distance. The statistics are computed on the first 500 points of the test set.
+
+Robust accuracy of Restricted ImageNet $l _ { 2 }$ -robust model   
+
+<table><tr><td>metric</td><td>E</td><td>DF</td><td>DAA- 1</td><td>DAA- 10</td><td>PGD- 1</td><td>PGD- 10</td><td>FAB- 1</td><td>FAB- 10</td></tr><tr><td rowspan="5">18</td><td>2/255</td><td>74.4</td><td>73.0</td><td>73.0</td><td>73.0</td><td>73.0</td><td>73.8</td><td>73.8</td></tr><tr><td>4/255</td><td>49.0</td><td>39.6</td><td>39.2</td><td>37.6</td><td>37.6</td><td>39.6</td><td>39.4</td></tr><tr><td>6/255</td><td>27.4</td><td>22.6</td><td>21.0</td><td>13.2</td><td>13.2</td><td>15.0</td><td>15.0</td></tr><tr><td>8/255</td><td>13.8</td><td>18.6</td><td>16.8</td><td>3.6</td><td>3.6</td><td>3.6</td><td>3.2</td></tr><tr><td>10/255</td><td>6.6</td><td>15.6</td><td>13.8</td><td>0.4</td><td>0.4</td><td>0.8</td><td>0.8</td></tr><tr><td></td><td></td><td></td><td></td><td>DF</td><td>PGD-</td><td>PGD-</td><td>FAB-</td><td>FAB-</td></tr><tr><td rowspan="5">12</td><td>2</td><td></td><td></td><td></td><td>1</td><td>50</td><td>1</td><td>10 72.8</td></tr><tr><td>3</td><td></td><td></td><td>74.2 61.6</td><td>71.8 51.4</td><td>71.8 51.0</td><td>72.8 52.4</td><td>52.4</td></tr><tr><td>4</td><td></td><td></td><td>45.6</td><td>31.0</td><td>30.8</td><td>34.4</td><td>33.8</td></tr><tr><td>5</td><td></td><td></td><td>34.6</td><td>20.4</td><td>20.4</td><td>22.6</td><td>21.8</td></tr><tr><td>6</td><td></td><td></td><td>25.2</td><td>9.6</td><td>9.6</td><td>11.8</td><td>11.6</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>PGD-</td><td></td><td></td><td>FAB-</td></tr><tr><td rowspan="5">l1</td><td></td><td></td><td>SparseFool</td><td></td><td>1</td><td>PGD- 5</td><td>FAB- 1</td><td>5</td></tr><tr><td>50</td><td></td><td></td><td>85.4</td><td>81.0</td><td>81.0</td><td>78.6</td><td>78.4</td></tr><tr><td>100</td><td></td><td></td><td>79.6</td><td>63.8</td><td>63.6</td><td>60.8</td><td>59.0</td></tr><tr><td>150</td><td></td><td></td><td>74.4</td><td>48.4</td><td>48.4</td><td>45.2</td><td>42.2</td></tr><tr><td>200 250</td><td></td><td></td><td>68.6 60.0</td><td>32.2 23.0</td><td>32.2 22.4</td><td>31.0 22.8</td><td>29.0 20.2</td></tr></table>
+
+![](images/0be78c0b205f94556f564bff0531004766b5d68fd7f6ceb6b6ef3b91fe2e6bc9.jpg)  
+Figure 3: We plot for different step sizes of PGD robust accuracy over iterations. In red the step size we used in the experiments of Section 3. We clearly see that our chosen step-size is on average the best one. The models used are those trained on MNIST (top row) and CIFAR-10 (bottom row).
+
+# B Analysis of the attacks
+
+# B.1 Choice of the step size of PGD
+
+We here show the performance of PGD wrt $l _ { 2 }$ on MNIST and CIFAR-10 under different choices of the step size. In particular we focus here on the largest $\epsilon$ and the middle $\epsilon$ values chosen in the evaluation where the different stepsize choices have the largest impact. We report the robust accuracy for at each of the 150 iterations. We test step sizes $\epsilon / t$ for $t \in \{ 1 , 2 , 4 , 1 0 , 2 5 , 7 5 \}$ . For each step size we run the attack 10 times with random initialization and show the run which achieves the lowest robust accuracy after 150 iterations. Note however that the behaviour of different runs varies minimally. In Figure 3 we show the results for the three models for MNIST and CIFAR-10 for two different choices of $\epsilon$ used in Section 3, with step size decreasing the blue becoming darker, while our chosen step size, that is $\epsilon / 4$ , is highlighted in red. We see that it achieves in all the models best or close to best robust accuracy and is clearly the best on average.
+
+# B.2 Evolution across iteration
+
+We here want to compare the evolution of the robust accuracy across the iterations of a single run of PGD and FAB, that is PGD-1 and FAB-1 from Tables 5 to 13. Since PGD performs 1 forward and 1 backward pass for each iteration and FAB 2 forward passes and 1 backward pass, we rescale the robust accuracy so to compare the two methods when they have exploited the same number of passes of the network. Then 300 passes correspond to 150 iterations of PGD and to 100 of FAB. In Figures 4, 5 and 6 we show the evolution of robust accuracy for the different dataset, models and threat models ( ${ \mathit { l } } _ { \infty }$ , $l _ { 2 }$ and $l _ { 1 }$ ), computed at the threshold $\epsilon$ median among the five used in Tables 5 to 13.
+
+![](images/394080302f40b08a5199f7f3435e273bccfdbce94e40a64e3c6d2627f1248542.jpg)  
+Figure 4: Evolution of accuracy across iterations on MNIST. We compare the robust accuracy of PGD-1 (magenta) and FAB-1 (black) as a function of the employed forward/backward passes in the algorithm (one iteration of PGD corresponds to 2 passes, one iteration of FAB corresponds to 3 passes). Models: plain in the first column, $l _ { \infty }$ -at in the second and $l _ { 2 }$ -at in the third. Threat models: ${ \mathit { l } } _ { \infty }$ in the first row, $l _ { 2 }$ in the second and $l _ { 1 }$ in the third. The thresholds $\epsilon$ used can be read above the plots. Note that the result of FAB-1 on ${ \mathit { l } } _ { \infty }$ -at wrt $l _ { 1 }$ does not match that in Table 6 due to a typo in the statistics in the table.
+
+![](images/e5545fdce41d433a09a74a6c59602e331c782191c55f6c6c75d988a99d575142.jpg)  
+Figure 5: Evolution of accuracy across iterations on CIFAR-10. We compare the robust accuracy of PGD-1 (magenta) and FAB-1 (black) as a function of the employed forward/backward passes in the algorithm (one iteration of PGD corresponds to 2 passes, one iteration of FAB corresponds to 3 passes). Models: plain in the first column, $l _ { \infty }$ -at in the second and $l _ { 2 }$ -at in the third. Threat models: ${ \mathit { l } } _ { \infty }$ in the first row, $l _ { 2 }$ in the second and $l _ { 1 }$ in the third. The thresholds $\epsilon$ used can be read above the plots.
+
+![](images/f662f60af47b70ef9e9be2d11736c4a60d3e7a49f05574d06c79cbdcac04334b.jpg)  
+Figure 6: Evolution of robust accuracy across iterations on Restricted ImageNet. We compare the robust accuracy of PGD-1 (magenta) and FAB-1 (black) as a function of the employed forward/backward passes in the algorithm (one iteration of PGD corresponds to 2 passes, one iteration of FAB corresponds to 3 passes). Models: plain in the first column, ${ \mathit { l } } _ { \infty }$ -at in the second and $l _ { 2 }$ -at in the third. Threat models: ${ \mathit { l } } _ { \infty }$ in the first row, $l _ { 2 }$ in the second and $l _ { 1 }$ in the third. The thresholds $\epsilon$ used can be read above the plots.

parse/train/SyZI0GWCZ/SyZI0GWCZ.md

@@ -0,0 +1,264 @@
+# DECISION-BASED ADVERSARIAL ATTACKS: RELIABLE ATTACKS AGAINST BLACK-BOX MACHINE LEARNING MODELS
+
+Wieland Brendel∗, Jonas Rauber∗ & Matthias Bethge Werner Reichardt Centre for Integrative Neuroscience, Eberhard Karls University Tubingen, Germany ¨ {wieland,jonas,matthias}@bethgelab.org
+
+# ABSTRACT
+
+Many machine learning algorithms are vulnerable to almost imperceptible perturbations of their inputs. So far it was unclear how much risk adversarial perturbations carry for the safety of real-world machine learning applications because most methods used to generate such perturbations rely either on detailed model information (gradient-based attacks) or on confidence scores such as class probabilities (score-based attacks), neither of which are available in most real-world scenarios. In many such cases one currently needs to retreat to transfer-based attacks which rely on cumbersome substitute models, need access to the training data and can be defended against. Here we emphasise the importance of attacks which solely rely on the final model decision. Such decision-based attacks are (1) applicable to real-world black-box models such as autonomous cars, (2) need less knowledge and are easier to apply than transfer-based attacks and (3) are more robust to simple defences than gradient- or score-based attacks. Previous attacks in this category were limited to simple models or simple datasets. Here we introduce the Boundary Attack, a decision-based attack that starts from a large adversarial perturbation and then seeks to reduce the perturbation while staying adversarial. The attack is conceptually simple, requires close to no hyperparameter tuning, does not rely on substitute models and is competitive with the best gradient-based attacks in standard computer vision tasks like ImageNet. We apply the attack on two black-box algorithms from Clarifai.com. The Boundary Attack in particular and the class of decision-based attacks in general open new avenues to study the robustness of machine learning models and raise new questions regarding the safety of deployed machine learning systems. An implementation of the attack is available as part of Foolbox (https://github.com/bethgelab/foolbox).
+
+![](images/29bebf96fcff48a12bde8b3b7384b02342998228447068b194f990d2e47a7930.jpg)  
+Figure 1: (Left) Taxonomy of adversarial attack methods. The Boundary Attack is applicable to realworld ML algorithms because it only needs access to the final decision of a model (e.g. class-label or transcribed sentence) and does not rely on model information like the gradient or the confidence scores. (Right) Application to the Clarifai Brand Recognition Model.
+
+# 1 INTRODUCTION
+
+Many high-performance machine learning algorithms used in computer vision, speech recognition and other areas are susceptible to minimal changes of their inputs (Szegedy et al., 2013). As a concrete example, a modern deep neural network like VGG-19 trained on object recognition might perfectly recognize the main object in an image as a tiger cat, but if the pixel values are only slightly perturbed in a specific way then the prediction of the very same network is drastically altered (e.g. to bus). These so-called adversarial perturbations are ubiquitous in many machine learning models and are often imperceptible to humans. Algorithms that seek to find such adversarial perturbations are generally denoted as adversarial attacks.
+
+Adversarial perturbations have drawn interest from two different sides. On the one side, they are worrisome for the integrity and security of deployed machine learning algorithms such as autonomous cars or face recognition systems. Minimal perturbations on street signs (e.g. turning a stop-sign into a $2 0 0 \mathrm { k m / h }$ speed limit) or street lights (e.g. turning a red into a green light) can have severe consequences. On the other hand, adversarial perturbations provide an exciting spotlight on the gap between the sensory information processing in humans and machines and thus provide guidance towards more robust, human-like architectures.
+
+Adversarial attacks can be roughly divided into three categories: gradient-based, score-based and transfer-based attacks (cp. Figure 1). Gradient-based and score-based attacks are often denoted as white-box and oracle attacks respectively, but we try to be as explicit as possible as to what information is being used in each category1. A severe problem affecting attacks in all of these categories is that they are surprisingly straight-forward to defend against:
+
+• Gradient-based attacks. Most existing attacks rely on detailed model information including the gradient of the loss w.r.t. the input. Examples are the Fast-Gradient Sign Method (FGSM), the Basic Iterative Method (BIM) (Kurakin et al., 2016), DeepFool (MoosaviDezfooli et al., 2015), the Jacobian-based Saliency Map Attack (JSMA) (Papernot et al., 2015), Houdini (Cisse et al., 2017) and the Carlini & Wagner attack (Carlini & Wagner, 2016a).
+
+Defence: A simple way to defend against gradient-based attacks is to mask the gradients, for example by adding non-differentiable elements either implicitly through means like defensive distillation (Papernot et al., 2016) or saturated non-linearities (Nayebi & Ganguli, 2017), or explicitly through means like non-differentiable classifiers (Lu et al., 2017).
+
+• Score-based attacks. A few attacks are more agnostic and only rely on the predicted scores (e.g. class probabilities or logits) of the model. On a conceptual level these attacks use the predictions to numerically estimate the gradient. This includes black-box variants of JSMA (Narodytska & Kasiviswanathan, 2016) and of the Carlini & Wagner attack (Chen et al., 2017) as well as generator networks that predict adversarials (Hayes & Danezis, 2017).
+
+Defence: It is straight-forward to severely impede the numerical gradient estimate by adding stochastic elements like dropout into the model. Also, many robust training methods introduce a sharp-edged plateau around samples (Tramer et al., 2017) which not only masks gradients themselves but also their numerical estimate.
+
+• Transfer-based attacks. Transfer-based attacks do not rely on model information but need information about the training data. This data is used to train a fully observable substitute model from which adversarial perturbations can be synthesized (Papernot et al., 2017a). They rely on the empirical observation that adversarial examples often transfer between models. If adversarial examples are created on an ensemble of substitute models the success rate on the attacked model can reach up to $100 \%$ in certain scenarios (Liu et al., 2016).
+
+Defence: A recent defence method against transfer attacks (Tramer et al., 2017), which is based on robust training on a dataset augmented by adversarial examples from an ensemble of substitute models, has proven highly successful against basically all attacks in the 2017 Kaggle Competition on Adversarial Attacks2.
+
+The fact that many attacks can be easily averted makes it often extremely difficult to assess whether a model is truly robust or whether the attacks are just too weak, which has lead to premature claims of robustness for DNNs (Carlini & Wagner, 2016b; Brendel & Bethge, 2017).
+
+This motivates us to focus on a category of adversarial attacks that has so far received fairly little attention:
+
+• Decision-based attacks. Direct attacks that solely rely on the final decision of the model (such as the top-1 class label or the transcribed sentence).
+
+The delineation of this category is justified for the following reasons: First, compared to score-based attacks decision-based attacks are much more relevant in real-world machine learning applications where confidence scores or logits are rarely accessible. At the same time decision-based attacks have the potential to be much more robust to standard defences like gradient masking, intrinsic stochasticity or robust training than attacks from the other categories. Finally, compared to transferbased attacks they need much less information about the model (neither architecture nor training data) and are much simpler to apply.
+
+There currently exists no effective decision-based attack that scales to natural datasets such as ImageNet and is applicable to deep neural networks (DNNs). The most relevant prior work is a variant of transfer attacks in which the training set needed to learn the substitute model is replaced by a synthetic dataset (Papernot et al., 2017b). This synthetic dataset is generated by the adversary alongside the training of the substitute; the labels for each synthetic sample are drawn from the black-box model. While this approach works well on datasets for which the intra-class variability is low (such as MNIST) it has yet to be shown that it scales to more complex natural datasets such as CIFAR or ImageNet. Other decision-based attacks are specific to linear or convex-inducing classifiers (Dalvi et al., 2004; Lowd & Meek, 2005; Nelson et al., 2012) and are not applicable to other machine learning models. The work by (Biggio et al., 2013) basically stands between transfer attacks and decision-based attacks in that the substitute model is trained on a dataset for which the labels have been observed from the black-box model. This attack still requires knowledge about the data distribution on which the black-box models was trained on and so we don’t consider it a pure decision-based attack. Finally, some naive attacks such as a line-search along a random direction away from the original sample can qualify as decision-based attacks but they induce large and very visible perturbations that are orders of magnitude larger than typical gradient-based, score-based or transfer-based attacks.
+
+Throughout the paper we focus on the threat scenario in which the adversary aims to change the decision of a model (either targeted or untargeted) for a particular input sample by inducing a minimal perturbation to the sample. The adversary can observe the final decision of the model for arbitrary inputs and it knows at least one perturbation, however large, for which the perturbed sample is adversarial.
+
+The contributions of this paper are as follows:
+
+• We emphasise decision-based attacks as an important category of adversarial attacks that are highly relevant for real-world applications and important to gauge model robustness. We introduce the first effective decision-based attack that scales to complex machine learning models and natural datasets. The Boundary Attack is (1) conceptually surprisingly simple, (2) extremely flexible, (3) requires little hyperparameter tuning and (4) is competitive with the best gradient-based attacks in both targeted and untargeted computer vision scenarios.   
+We show that the Boundary Attack is able to break previously suggested defence mechanisms like defensive distillation. We demonstrate the practical applicability of the Boundary Attack on two black-box machine learning models for brand and celebrity recognition available on Clarifai.com.
+
+# 1.1 NOTATION
+
+Throughout the paper we use the following notation: $^ o$ refers to the original input (e.g. an image), $\begin{array} { r } { y = \bar { F } ( o ) } \end{array}$ refers to the full prediction of the model $F ( \cdot )$ (e.g. logits or probabilities), $y _ { m a x }$ is the
+
+predicted label (e.g. class-label). Similarly, $\tilde { o }$ refers to the adversarially perturbed image, $\tilde { o } ^ { k }$ refers to the perturbed image at the $k$ -th step of an attack algorithm. Vectors are denoted in bold.
+
+# 2 BOUNDARY ATTACK
+
+The basic intuition behind the boundary attack algorithm is depicted in Figure 2: the algorithm is initialized from a point that is already adversarial and then performs a random walk along the boundary between the adversarial and the non-adversarial region such that (1) it stays in the adversarial region and (2) the distance towards the target image is reduced. In other words we perform rejection sampling with a suitable proposal distribution $\mathcal { P }$ to find progressively smaller adversarial perturbations according to a given adversarial criterion $c ( . )$ . The basic logic of the algorithm is described in Algorithm 1, each individual building block is detailed in the next subsections.
+
+Data: original image o, adversarial criterion $c ( . )$ , decision of model $d ( . )$   
+Result: adversarial example $\tilde { o }$ such that the distance $d ( \pmb { o } , \tilde { \pmb { o } } ) = \lVert \pmb { o } - \tilde { \pmb { o } } \rVert _ { 2 } ^ { 2 }$ is minimized   
+initialization: $k = 0$ , $\tilde { \sigma } ^ { 0 } \sim \mathcal { U } ( 0 , 1 )$ s.t. $\tilde { \bullet } ^ { 0 }$ is adversarial;   
+while $k <$ maximum number of steps do draw random perturbation from proposal distribution $\eta _ { k } \sim \mathcal { P } ( \tilde { o } ^ { k - 1 } )$ ; if $\tilde { o } ^ { k - 1 } + \eta _ { k }$ is adversarial then set $\tilde { \pmb { o } } ^ { k } = \tilde { \pmb { o } } ^ { k - 1 } + \eta _ { k }$ ; else set $\tilde { o } ^ { k } = \tilde { o } ^ { k - 1 }$ ; end $k = k + 1$   
+end
+
+Algorithm 1: Minimal version of the Boundary Attack.
+
+# 2.1 INITIALISATION
+
+The Boundary Attack needs to be initialized with a sample that is already adversarial3. In an untargeted scenario we simply sample from a maximum entropy distribution given the valid domain of the input. In the computer vision applications below, where the input is constrained to a range of [0, 255] per pixel, we sample each pixel in the initial image $\mathbf { \tilde { o } ^ { 0 } }$ from a uniform distribution $\mathcal { U } ( 0 , \bar { 2 } 5 5 )$ . We reject samples that are not adversarial. In a targeted scenario we start from any sample that is classified by the model as being from the target class.
+
+# 2.2 PROPOSAL DISTRIBUTION
+
+The efficiency of the algorithm crucially depends on the proposal distribution $\mathcal { P }$ , i.e. which random directions are explored in each step of the algorithm. The optimal proposal distribution will generally depend on the domain and / or model to be attacked, but for all vision-related problems tested here a very simple proposal distribution worked surprisingly well. The basic idea behind this proposal distribution is as follows: in the $k$ -th step we want to draw perturbations $\eta ^ { k }$ from a maximum entropy distribution subject to the following constraints:
+
+1. The perturbed sample lies within the input domain,
+
+$$
+\tilde { o } _ { i } ^ { k - 1 } + \eta _ { i } ^ { k } \in [ 0 , 2 5 5 ] .
+$$
+
+2. The perturbation has a relative size of $\delta$ ,
+
+$$
+\left\| \pmb { \eta } ^ { k } \right\| _ { 2 } = \delta \cdot d ( \mathbf { o } , \tilde { \mathbf { o } } ^ { \mathbf { k } - \mathbf { 1 } } ) .
+$$
+
+3. The perturbation reduces the distance of the perturbed image towards the original input by a relative amount $\epsilon$ ,
+
+$$
+d ( { \bf o } , \tilde { \bf o } ^ { { \bf k } - 1 } ) - d ( { \bf o } , \tilde { \bf o } ^ { { \bf k } - 1 } + \eta ^ { k } ) = \epsilon \cdot d ( { \bf o } , \tilde { \bf o } ^ { { \bf k } - 1 } ) .
+$$
+
+![](images/c9a81d4b166c0bc0a33a374cca7d988a2eea34ac136d9734d6e84454672850a0.jpg)  
+Figure 2: (Left) In essence the Boundary Attack performs rejection sampling along the boundary between adversarial and non-adversarial images. (Center) In each step we draw a new random direction by (#1) drawing from an iid Gaussian and projecting on a sphere, and by (#2) making a small move towards the target image. (Right) The two step-sizes (orthogonal and towards the original input) are dynamically adjusted according to the local geometry of the boundary.
+
+In practice it is difficult to sample from this distribution, and so we resort to a simpler heuristic: first, we sample from an iid Gaussian distribution $\eta _ { i } ^ { k } \sim \mathcal { N } ( 0 , 1 )$ and then rescale and clip the sample such that (1) and (2) hold. In a second step we project $\eta ^ { k }$ onto a sphere around the original image $^ o$ such that $d ( o , \tilde { o } ^ { k - 1 } + \eta ^ { k } ) = d ( o , \tilde { o } ^ { k - 1 } )$ and (1) hold. We denote this as the orthogonal perturbation and use it later for hyperparameter tuning. In the last step we make a small movement towards the original image such that (1) and (3) hold. For high-dimensional inputs and small $\delta , \epsilon$ the constraint (2) will also hold approximately.
+
+# 2.3 ADVERSARIAL CRITERION
+
+A typical criterion by which an input is classified as adversarial is misclassification, i.e. whether the model assigns the perturbed input to some class different from the class label of the original input. Another common choice is targeted misclassification for which the perturbed input has to be classified in a given target class. Other choices include top-k misclassification (the top-k classes predicted for the perturbed input do not contain the original class label) or thresholds on certain confidence scores. Outside of computer vision many other choices exist such as criteria on the worderror rates. In comparison to most other attacks, the Boundary Attack is extremely flexible with regards to the adversarial criterion. It basically allows any criterion (including non-differentiable ones) as long as for that criterion an initial adversarial can be found (which is trivial in most cases).
+
+# 2.4 HYPERPARAMETER ADJUSTMENT
+
+The Boundary Attack has only two relevant parameters: the length of the total perturbation $\delta$ and the length of the step $\epsilon$ towards the original input (see Fig. 2). We adjust both parameters dynamically according to the local geometry of the boundary. The adjustment is inspired by Trust Region methods. In essence, we first test whether the orthogonal perturbation is still adversarial. If this is true, then we make a small movement towards the target and test again. The orthogonal step tests whether the step-size is small enough so that we can treat the decision boundary between the adversarial and the non-adversarial region as being approximately linear. If this is the case, then we expect around $50 \%$ of the orthogonal perturbations to still be adversarial. If this ratio is much lower, we reduce the step-size $\delta$ , if it is close to $50 \%$ or higher we increase it. If the orthogonal perturbation is still adversarial we add a small step towards the original input. The maximum size of this step depends on the angle of the decision boundary in the local neighbourhood (see also Figure 2). If the success rate is too small we decrease $\epsilon$ , if it is too large we increase it. Typically, the closer we get to the original image, the flatter the decision boundary becomes and the smaller $\epsilon$ has to be to still make progress. The attack is converged whenever $\epsilon$ converges to zero.
+
+# 3 COMPARISON WITH OTHER ATTACKS
+
+We quantify the performance of the Boundary Attack on three different standard datasets: MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky & Hinton, 2009) and ImageNet-1000 (Deng et al., 2009). To make the comparison with previous results as easy and transparent as possible, we here use the same MNIST and CIFAR networks as Carlini & Wagner (2016a)4. In a nutshell, both the MNIST and CIFAR model feature nine layers with four convolutional layers, two max-pooling layers and two fully-connected layers. For all details, including training parameters, we refer the reader to (Carlini & Wagner, 2016a). On ImageNet we use the pretrained networks VGG-19 (Simonyan & Zisserman, 2014), ResNet-50 (He et al., 2015) and Inception-v3 (Szegedy et al., 2015) provided by Keras5.
+
+We evaluate the Boundary Attack in two settings: an (1) untargeted setting in which the adversarial perturbation flips the label of the original sample to any other label, and a (2) targeted setting in which the adversarial flips the label to a specific target class. In the untargeted setting we compare the Boundary Attack against three gradient-based attack algorithms:
+
+• Fast-Gradient Sign Method (FGSM). FGSM is among the simplest and most widely used untargeted adversarial attack methods. In a nutshell, FGSM computes the gradient ${ \textbf { 0 } } =$ $\nabla _ { o } \mathcal { L } ( o , c )$ that maximizes the loss $\mathcal { L }$ for the true class-label $c$ and then seeks the smallest $\epsilon$ for which $\mathbf { \omega } _ { o + \epsilon } . \mathbf { \omega } _ { g }$ is still adversarial. We use the implementation in Foolbox 0.10.0 (Rauber et al., 2017). DeepFool. DeepFool is a simple yet very effective attack. In each iteration it computes for each class $\ell \neq \ell _ { 0 }$ the minimum distance $d ( \ell , \ell _ { 0 } )$ that it takes to reach the class boundary by approximating the model classifier with a linear classifier. It then makes a corresponding step in the direction of the class with the smallest distance. We use the implementation in Foolbox 0.10.0 (Rauber et al., 2017). Carlini & Wagner. The attack by Carlini & Wagner (Carlini & Wagner, 2016a) is essentially a refined iterative gradient attack that uses the Adam optimizer, multiple starting points, a tanh-nonlinearity to respect box-constraints and a max-based adversarial constraint function. We use the original implementation provided by the authors with all hyperparameters left at their default values4.
+
+To evaluate the success of each attack we use the following metric: let $\pmb { \eta } _ { A , M } ( \pmb { o } _ { i } ) \in \mathbb { R } ^ { N }$ be the adversarial perturbation that the attack $A$ finds on model $M$ for the $i$ -th sample $\mathbf { o } _ { i }$ . The total score $\mathcal { S } _ { A }$ for $A$ is the median squared L2-distance across all samples,
+
+$$
+\mathcal { S } _ { A } ( M ) = \mathrm { m e d i a n } \left( \frac { 1 } { N } \left. \pmb { \eta } _ { A , M } ( \pmb { o } _ { i } ) \right. _ { 2 } ^ { 2 } \right) .
+$$
+
+For MNIST and CIFAR we evaluate 1000 randomly drawn samples from the validation set, for ImageNet we use 250 images.
+
+# 3.1 UNTARGETED ATTACK
+
+In the untargeted setting an adversarial is any image for which the predicted label is different from the label of the original image. We show adversarial samples synthesized by the Boundary Attack for each dataset in Figure 3. The score (4) for each attack and each dataset is as follows:
+
+ImageNet   
+
+<table><tr><td></td><td>Attack Type</td><td>MNIST</td><td>CIFAR</td><td>VGG-19</td><td>ResNet-50</td><td>Inception-v3</td></tr><tr><td>FGSM</td><td>gradient-based</td><td>4.2e-02</td><td>2.5e-05</td><td>1.0e-06</td><td>1.0e-06</td><td>9.7e-07</td></tr><tr><td>DeepFool</td><td>gradient-based</td><td>4.3e-03</td><td>5.8e-06</td><td>1.9e-07</td><td>7.5e-08</td><td>5.2e-08</td></tr><tr><td>Carlini &amp; Wagner</td><td>gradient-based</td><td>2.2e-03</td><td>7.5e-06</td><td>5.7e-07</td><td>2.2e-07</td><td>7.6e-08</td></tr><tr><td>Boundary (ours)</td><td>decision-based</td><td>3.6e-03</td><td>5.6e-06</td><td>2.9e-07</td><td>1.0e-07</td><td>6.5e-08</td></tr></table>
+
+![](images/eeb7e498a6f3dda6b80f2fdd07715a54125dc071e8a27bf1b9e1a9682e877d9e.jpg)  
+Figure 3: Adversarial examples generated by the Boundary Attack for an MNIST, CIFAR and ImageNet network. For MNIST, the difference shows positive (blue) and negative (red) changes. For CIFAR and ImageNet, we take the norm across color channels. All differences have been scaled up for improved visibility.
+
+![](images/224fd7d916d70367db5cbec645c4cb5aa8c9276b5fe4430a32d62d409dd41f11.jpg)  
+Figure 4: Example of an untargeted attack. Here the goal is to synthesize an image that is as close as possible (in L2-metric) to the original image while being misclassified (the original image is correctly classified). For each image we report the total number of model calls (predictions) until that point (above the image) and the mean squared error between the adversarial and the original (below the image).
+
+Despite its simplicity the Boundary Attack is competitive with gradient-based attacks in terms of the minimal adversarial perturbations and very stable against the choice of the initial point (Figure 5). This finding is quite remarkable given that gradient-based attacks can fully observe the model whereas the Boundary Attack is severely restricted to the final class prediction. To compensate for this lack of information the Boundary Attack needs many more iterations to converge. As a rough measure for the run-time of an attack independent of the quality of its implementation we tracked the number of forward passes (predictions) and backward passes (gradients) through the network requested by each of the attacks to find an adversarial for ResNet-50: averaged over 20 samples and under the same conditions as before, DeepFool needs about 7 forward and 37 backward passes, the Carlini & Wagner attack requires 16.000 forward and the same number of backward passes, and the Boundary Attack uses 1.200.000 forward passes but zero backward passes. While that (unsurprisingly) makes the Boundary Attack more expensive to run it is important to note that the Boundary Attacks needs much fewer iterations if one is only interested in imperceptible perturbations, see figures 4 and 6.
+
+# 3.2 TARGETED ATTACK
+
+We can also apply the Boundary Attack in a targeted setting. In this case we initialize the attack from a sample of the target class that is correctly identified by the model. A sample trajectory from the starting point to the original sample is shown in Figure 7. After around $1 0 ^ { 4 }$ calls to the model the perturbed image is already clearly identified as a cat by humans and contains no trace of the Dalmatian dog, as which the image is still classified by the model.
+
+![](images/a182715ad2d667ed65ca2ebb2779a3bcb68058efa6b45bdb4d123f50179eb937.jpg)  
+Figure 5: Adversarial perturbation (difference between the adversarial and the original image) for ten repetitions of the Boundary Attack on the same image. There are basically two different minima with similar distance (first row and second row) to which the Boundary Attack converges.
+
+![](images/c6a777ffa8fb8799bffa6b639846bc5e2222923e9088233bf6dffdd0db0a6b1f.jpg)  
+Figure 6: Distance between adversarial and original image over number of model calls for 12 different images (until convergence). Very few steps are already sufficient to get almost imperceptible perturbations.
+
+![](images/3762b35219c7d357b48af44610d0275cae626e52f01443af83b519d540c06334.jpg)  
+Figure 7: Example of a targeted attack. Here the goal is to synthesize an image that is as close as possible (in L2-metric) to a given image of a tiger cat (2nd row, right) but is classified as a dalmatian dog. For each image we report the total number of model calls (predictions) until that point.
+
+In order to compare the Boundary Attack to Carlini & Wagner we define the target target label for each sample in the following way: on MNIST and CIFAR a sample with label $\ell$ gets the target label $\ell + 1$ modulo 10. On ImageNet we draw the target label randomly but consistent across attacks. The results are as follows:
+
+<table><tr><td></td><td>Attack Type</td><td>MNIST</td><td>CIFAR</td><td>VGG-19</td></tr><tr><td>Carlini &amp;Wagner</td><td>gradient-based</td><td>4.8e-03</td><td>3.0e-05</td><td>5.7e-06</td></tr><tr><td>Boundary (ours)</td><td>decision-based</td><td>6.5e-03</td><td>3.3e-05</td><td>9.9e-06</td></tr></table>
+
+# 4 THE IMPORTANCE OF DECISION-BASED ATTACKS TO EVALUATE MODEL ROBUSTNESS
+
+As discussed in the introduction, many attack methods are straight-forward to defend against. One common nuisance is gradient masking in which a model is implicitely or explicitely modified to yield masked gradients. An interesting example is the saturated sigmoid network (Nayebi & Ganguli, 2017) in which an additional regularization term leads the sigmoid activations to saturate, which in turn leads to vanishing gradients and failing gradient-based attacks (Brendel & Bethge, 2017).
+
+Another example is defensive distillation (Papernot et al., 2016). In a nutshell defensive distillation uses a temperature-augmented softmax of the type
+
+$$
+s o f t m a x ( x , T ) _ { i } = \frac { e ^ { x _ { i } / T } } { \sum _ { j } e ^ { x _ { j } / T } }
+$$
+
+and works as follows:
+
+1. Train a teacher network as usual but with temperature $T$ .   
+2. Train a distilled network—with the same architecture as the teacher—on the softmax outputs of the teacher. Both the distilled network and the teacher use temperature $T$ .   
+3. Evaluate the distilled network at temperature $T = 1$ at test time.
+
+Initial results were promising: the success rate of gradient-based attacks dropped from close to $100 \%$ down to $0 . 5 \%$ . It later became clear that the distilled networks only appeared to be robust because they masked their gradients of the cross-entropy loss (Carlini & Wagner, 2016b): as the temperature of the softmax is decreased at test time, the input to the softmax increases by a factor of $T$ and so the probabilities saturate at 0 and 1. This leads to vanishing gradients of the cross-entropy loss w.r.t. to the input on which gradient-based attacks rely. If the same attacks are instead applied to the logits the success rate recovers to almost $1 0 0 \%$ (Carlini & Wagner, 2016a).
+
+Decision-based attacks are immune to such defences. To demonstrate this we here apply the Boundary Attack to two distilled networks trained on MNIST and CIFAR. The architecture is the same as in section 3 and we use the implementation and training protocol by (Carlini & Wagner, 2016a) which is available at https://github.com/carlini/nn_robust_attacks. Most importantly, we do not operate on the logits but provide only the class label with maximum probability to the Boundary Attack. The results are as follows:
+
+<table><tr><td rowspan="2"></td><td rowspan="2">Attack Type</td><td colspan="2">MNIST</td><td colspan="2">CIFAR</td></tr><tr><td>standard</td><td>distilled</td><td>standard</td><td>distilled</td></tr><tr><td>FGSM</td><td>gradient-based</td><td>4.2e-02</td><td>fails</td><td>2.5e-05</td><td>fails</td></tr><tr><td>Boundary (ours)</td><td>decision-based</td><td>3.6e-03</td><td>4.2e-03</td><td>5.6e-06</td><td>1.3e-05</td></tr></table>
+
+The size of the adversarial perturbations that the Boundary Attack finds is fairly similar for the distilled and the undistilled network. This demonstrates that defensive distillation does not significantly increase the robustness of network models and that the Boundary Attack is able to break defences based on gradient masking.
+
+# 5 ATTACKS ON REAL-WORLD APPLICATIONS
+
+In many real-world machine learning applications the attacker has no access to the architecture or the training data but can only observe the final decision. This is true for security systems (e.g. face identification), autonomous cars or speech recognition systems like Alexa or Cortana.
+
+In this section we apply the Boundary Attack to two models of the cloud-based computer vision API by Clarifai6. The first model identifies brand names in natural images and recognizes over 500 brands. The second model identifies celebrities and can recognize over 10.000 individuals. Multiple identifications per image are possible but we only consider the one with the highest confidence score. It is important to note that Clarifai does provide confidence scores for each identified class (but not for all possible classes). However, in our experiments we do not provide this confidence score to the Boundary Attack. Instead, our attack only receives the name of the identified object (e.g. Pepsi or Verizon in the brand-name detection task).
+
+We selected several samples of natural images with clearly visible brand names or portraits of celebrities. We then make a square crop and resize the image to $1 0 0 \times 1 0 0$ pixels. For each sample we make sure that the brand or the celebrity is clearly visible and that the corresponding Clarifai model correctly identifies the content. The adversarial criterion was misclassification, i.e. Clarifai should report a different brand / celebrity or None on the adversarially perturbed sample.
+
+![](images/e7839d3f976c5105c19b1e4c52f53e928122f89340e84a1444ce3924a0bbd7dd.jpg)  
+Figure 8: Adversarial examples generated by the Boundary Attack for two black-box models by Clarifai for brand-detection (left side) and celebrity detection (right side).
+
+We show five samples for each model alongside the adversarial image generated by the Boundary Attack in Figure 8. We generally observed that the Clarifai models were more difficult to attack than ImageNet models like VGG-19: while for some samples we did succeed to find adversarial perturbations of the same order $( 1 e ^ { - 7 } )$ as in section 3 (e.g. for Shell or $S A P$ ), most adversarial perturbations were on the order of $1 e ^ { - 2 }$ to $1 e ^ { - 3 }$ resulting in some slightly noticeable noise in some adversarial examples. Nonetheless, for most samples the original and the adversarial image are close to being perceptually indistinguishable.
+
+# 6 DISCUSSION & OUTLOOK
+
+In this paper we emphasised the importance of a mostly neglected category of adversarial attacks— decision-based attacks—that can find adversarial examples in models for which only the final decision can be observed. We argue that this category is important for three reasons: first, attacks in this class are highly relevant for many real-world deployed machine learning systems like autonomous cars for which the internal decision making process is unobservable. Second, attacks in this class do not rely on substitute models that are trained on similar data as the model to be attacked, thus making real-world applications much more straight-forward. Third, attacks in this class have the potential to be much more robust against common deceptions like gradient masking, intrinsic stochasticity or robust training.
+
+We also introduced the first effective attack in this category that is applicable to general machine learning algorithms and complex natural datasets: the Boundary Attack. At its core the Boundary Attack follows the decision boundary between adversarial and non-adversarial samples using a very simple rejection sampling algorithm in conjunction with a simple proposal distribution and a dynamic step-size adjustment inspired by Trust Region methods. Its basic operating principle— starting from a large perturbation and successively reducing it—inverts the logic of essentially all previous adversarial attacks. Besides being surprisingly simple, the Boundary attack is also extremely flexible in terms of the possible adversarial criteria and performs on par with gradient-based attacks on standard computer vision tasks in terms of the size of minimal perturbations.
+
+The mere fact that a simple constrained iid Gaussian distribution can serve as an effective proposal perturbation for each step of the Boundary attack is surprising and sheds light on the brittle information processing of current computer vision architectures. Nonetheless, there are many ways in which the Boundary attack can be made even more effective, in particular by learning a suitable proposal distribution for a given model or by conditioning the proposal distribution on the recent history of successful and unsuccessful proposals.
+
+Decision-based attacks will be highly relevant to assess the robustness of machine learning models and to highlight the security risks of closed-source machine learning systems like autonomous cars. We hope that the Boundary attack will inspire future work in this area.
+
+# ACKNOWLEDGMENTS
+
+This work was supported by the Carl Zeiss Foundation (0563-2.8/558/3), the Bosch Forschungsstiftung (Stifterverband, T113/30057/17), the International Max Planck Research School for Intelligent Systems (IMPRS-IS), the German Research Foundation (DFG, CRC 1233, Robust Vision: Inference Principles and Neural Mechanisms) and the Intelligence Advanced Research Projects Activity (IARPA) via Department of Interior/Interior Business Center (DoI/IBC) contract number D16PC00003. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon. Disclaimer: The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of IARPA, DoI/IBC, or the U.S. Government.
+
+# REFERENCES
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013.
+
+Wieland Brendel and Matthias Bethge. Comment on “biologically inspired protection of deep networks from adversarial attacks”. CoRR, abs/1704.01547, 2017. URL http://arxiv.org/ abs/1704.01547.
+
+Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. CoRR, abs/1608.04644, 2016a. URL http://arxiv.org/abs/1608.04644.
+
+Nicholas Carlini and David A. Wagner. Defensive distillation is not robust to adversarial examples. CoRR, abs/1607.04311, 2016b. URL http://arxiv.org/abs/1607.04311.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. CoRR, abs/1708.03999, 2017. URL http://arxiv.org/abs/1708.03999.
+
+Moustapha Cisse, Yossi Adi, Natalia Neverova, and Joseph Keshet. Houdini: Fooling deep structured prediction models. CoRR, abs/1707.05373, 2017. URL http://arxiv.org/abs/ 1707.05373.
+
+Nilesh Dalvi, Pedro Domingos, Mausam, Sumit Sanghai, and Deepak Verma. Adversarial classification. In Proceedings of the Tenth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’04, pp. 99–108, New York, NY, USA, 2004. ACM. ISBN 1-58113-888-1. doi: 10.1145/1014052.1014066. URL http://doi.acm.org/10.1145/ 1014052.1014066.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009.
+
+Jamie Hayes and George Danezis. Machine learning as an adversarial service: Learning blackbox adversarial examples. CoRR, abs/1708.05207, 2017. URL http://arxiv.org/abs/ 1708.05207.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial examples in the physical world. CoRR, abs/1607.02533, 2016. URL http://arxiv.org/abs/1607.02533.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. CoRR, abs/1611.02770, 2016. URL http://arxiv.org/abs/ 1611.02770.
+
+Daniel Lowd and Christopher Meek. Adversarial learning. In Proceedings of the Eleventh ACM SIGKDD International Conference on Knowledge Discovery in Data Mining, KDD ’05, pp. 641– 647, New York, NY, USA, 2005. ACM. ISBN 1-59593-135-X. doi: 10.1145/1081870.1081950. URL http://doi.acm.org/10.1145/1081870.1081950.
+
+Jiajun Lu, Theerasit Issaranon, and David A. Forsyth. Safetynet: Detecting and rejecting adversarial examples robustly. CoRR, abs/1704.00103, 2017. URL http://arxiv.org/abs/1704. 00103.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. CoRR, abs/1511.04599, 2015. URL http: //arxiv.org/abs/1511.04599.
+
+Nina Narodytska and Shiva Prasad Kasiviswanathan. Simple black-box adversarial perturbations for deep networks. CoRR, abs/1612.06299, 2016. URL http://arxiv.org/abs/1612. 06299.
+
+Aran Nayebi and Surya Ganguli. Biologically inspired protection of deep networks from adversarial attacks. CoRR, abs/1703.09202, 2017. URL http://arxiv.org/abs/1703.09202.
+
+Blaine Nelson, Benjamin I. P. Rubinstein, Ling Huang, Anthony D. Joseph, Steven J. Lee, Satish Rao, and J. D. Tygar. Query strategies for evading convex-inducing classifiers. J. Mach. Learn. Res., 13:1293–1332, May 2012. ISSN 1532-4435. URL http://dl.acm.org/citation. cfm?id=2188385.2343688.
+
+Nicolas Papernot, Patrick D. McDaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. CoRR, abs/1511.07528, 2015. URL http://arxiv.org/abs/1511.07528.
+
+Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017a.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z. Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, ASIA CCS ’17, pp. 506–519, New York, NY, USA, 2017b. ACM. ISBN 978-1-4503-4944-4. doi: 10.1145/3052973.3053009. URL http://doi.acm.org/10.1145/3052973.3053009.
+
+Jonas Rauber, Wieland Brendel, and Matthias Bethge. Foolbox v0.8.0: A python toolbox to benchmark the robustness of machine learning models. CoRR, abs/1707.04131, 2017. URL http://arxiv.org/abs/1707.04131.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. CoRR, abs/1312.6199, 2013. URL http://arxiv.org/abs/1312.6199.
+
+Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015. URL http://arxiv.org/abs/1512.00567.
+
+Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. CoRR, abs/1705.07204, May 2017. URL http: //arxiv.org/abs/1705.07204.

parse/train/SyZI0GWCZ/SyZI0GWCZ_content_list.json

@@ -0,0 +1,1403 @@
+[
+    {
+        "type": "text",
+        "text": "DECISION-BASED ADVERSARIAL ATTACKS: RELIABLE ATTACKS AGAINST BLACK-BOX MACHINE LEARNING MODELS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            99,
+            825,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wieland Brendel∗, Jonas Rauber∗ & Matthias Bethge Werner Reichardt Centre for Integrative Neuroscience, Eberhard Karls University Tubingen, Germany ¨ {wieland,jonas,matthias}@bethgelab.org ",
+        "bbox": [
+            184,
+            195,
+            555,
+            252
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            287,
+            544,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many machine learning algorithms are vulnerable to almost imperceptible perturbations of their inputs. So far it was unclear how much risk adversarial perturbations carry for the safety of real-world machine learning applications because most methods used to generate such perturbations rely either on detailed model information (gradient-based attacks) or on confidence scores such as class probabilities (score-based attacks), neither of which are available in most real-world scenarios. In many such cases one currently needs to retreat to transfer-based attacks which rely on cumbersome substitute models, need access to the training data and can be defended against. Here we emphasise the importance of attacks which solely rely on the final model decision. Such decision-based attacks are (1) applicable to real-world black-box models such as autonomous cars, (2) need less knowledge and are easier to apply than transfer-based attacks and (3) are more robust to simple defences than gradient- or score-based attacks. Previous attacks in this category were limited to simple models or simple datasets. Here we introduce the Boundary Attack, a decision-based attack that starts from a large adversarial perturbation and then seeks to reduce the perturbation while staying adversarial. The attack is conceptually simple, requires close to no hyperparameter tuning, does not rely on substitute models and is competitive with the best gradient-based attacks in standard computer vision tasks like ImageNet. We apply the attack on two black-box algorithms from Clarifai.com. The Boundary Attack in particular and the class of decision-based attacks in general open new avenues to study the robustness of machine learning models and raise new questions regarding the safety of deployed machine learning systems. An implementation of the attack is available as part of Foolbox (https://github.com/bethgelab/foolbox). ",
+        "bbox": [
+            232,
+            320,
+            764,
+            652
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/29bebf96fcff48a12bde8b3b7384b02342998228447068b194f990d2e47a7930.jpg",
+        "image_caption": [
+            "Figure 1: (Left) Taxonomy of adversarial attack methods. The Boundary Attack is applicable to realworld ML algorithms because it only needs access to the final decision of a model (e.g. class-label or transcribed sentence) and does not rely on model information like the gradient or the confidence scores. (Right) Application to the Clarifai Brand Recognition Model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            675,
+            823,
+            789
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            336,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Many high-performance machine learning algorithms used in computer vision, speech recognition and other areas are susceptible to minimal changes of their inputs (Szegedy et al., 2013). As a concrete example, a modern deep neural network like VGG-19 trained on object recognition might perfectly recognize the main object in an image as a tiger cat, but if the pixel values are only slightly perturbed in a specific way then the prediction of the very same network is drastically altered (e.g. to bus). These so-called adversarial perturbations are ubiquitous in many machine learning models and are often imperceptible to humans. Algorithms that seek to find such adversarial perturbations are generally denoted as adversarial attacks. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            244
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial perturbations have drawn interest from two different sides. On the one side, they are worrisome for the integrity and security of deployed machine learning algorithms such as autonomous cars or face recognition systems. Minimal perturbations on street signs (e.g. turning a stop-sign into a $2 0 0 \\mathrm { k m / h }$ speed limit) or street lights (e.g. turning a red into a green light) can have severe consequences. On the other hand, adversarial perturbations provide an exciting spotlight on the gap between the sensory information processing in humans and machines and thus provide guidance towards more robust, human-like architectures. ",
+        "bbox": [
+            174,
+            252,
+            825,
+            349
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Adversarial attacks can be roughly divided into three categories: gradient-based, score-based and transfer-based attacks (cp. Figure 1). Gradient-based and score-based attacks are often denoted as white-box and oracle attacks respectively, but we try to be as explicit as possible as to what information is being used in each category1. A severe problem affecting attacks in all of these categories is that they are surprisingly straight-forward to defend against: ",
+        "bbox": [
+            176,
+            356,
+            825,
+            426
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Gradient-based attacks. Most existing attacks rely on detailed model information including the gradient of the loss w.r.t. the input. Examples are the Fast-Gradient Sign Method (FGSM), the Basic Iterative Method (BIM) (Kurakin et al., 2016), DeepFool (MoosaviDezfooli et al., 2015), the Jacobian-based Saliency Map Attack (JSMA) (Papernot et al., 2015), Houdini (Cisse et al., 2017) and the Carlini & Wagner attack (Carlini & Wagner, 2016a). ",
+        "bbox": [
+            218,
+            438,
+            823,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Defence: A simple way to defend against gradient-based attacks is to mask the gradients, for example by adding non-differentiable elements either implicitly through means like defensive distillation (Papernot et al., 2016) or saturated non-linearities (Nayebi & Ganguli, 2017), or explicitly through means like non-differentiable classifiers (Lu et al., 2017). ",
+        "bbox": [
+            228,
+            525,
+            823,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Score-based attacks. A few attacks are more agnostic and only rely on the predicted scores (e.g. class probabilities or logits) of the model. On a conceptual level these attacks use the predictions to numerically estimate the gradient. This includes black-box variants of JSMA (Narodytska & Kasiviswanathan, 2016) and of the Carlini & Wagner attack (Chen et al., 2017) as well as generator networks that predict adversarials (Hayes & Danezis, 2017). ",
+        "bbox": [
+            220,
+            585,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Defence: It is straight-forward to severely impede the numerical gradient estimate by adding stochastic elements like dropout into the model. Also, many robust training methods introduce a sharp-edged plateau around samples (Tramer et al., 2017) which not only masks gradients themselves but also their numerical estimate. ",
+        "bbox": [
+            227,
+            659,
+            823,
+            713
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Transfer-based attacks. Transfer-based attacks do not rely on model information but need information about the training data. This data is used to train a fully observable substitute model from which adversarial perturbations can be synthesized (Papernot et al., 2017a). They rely on the empirical observation that adversarial examples often transfer between models. If adversarial examples are created on an ensemble of substitute models the success rate on the attacked model can reach up to $100 \\%$ in certain scenarios (Liu et al., 2016). ",
+        "bbox": [
+            218,
+            718,
+            825,
+            801
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Defence: A recent defence method against transfer attacks (Tramer et al., 2017), which is based on robust training on a dataset augmented by adversarial examples from an ensemble of substitute models, has proven highly successful against basically all attacks in the 2017 Kaggle Competition on Adversarial Attacks2. ",
+        "bbox": [
+            232,
+            806,
+            823,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The fact that many attacks can be easily averted makes it often extremely difficult to assess whether a model is truly robust or whether the attacks are just too weak, which has lead to premature claims of robustness for DNNs (Carlini & Wagner, 2016b; Brendel & Bethge, 2017). ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "This motivates us to focus on a category of adversarial attacks that has so far received fairly little attention: ",
+        "bbox": [
+            174,
+            152,
+            823,
+            180
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• Decision-based attacks. Direct attacks that solely rely on the final decision of the model (such as the top-1 class label or the transcribed sentence). ",
+        "bbox": [
+            210,
+            193,
+            823,
+            220
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The delineation of this category is justified for the following reasons: First, compared to score-based attacks decision-based attacks are much more relevant in real-world machine learning applications where confidence scores or logits are rarely accessible. At the same time decision-based attacks have the potential to be much more robust to standard defences like gradient masking, intrinsic stochasticity or robust training than attacks from the other categories. Finally, compared to transferbased attacks they need much less information about the model (neither architecture nor training data) and are much simpler to apply. ",
+        "bbox": [
+            174,
+            233,
+            825,
+            330
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There currently exists no effective decision-based attack that scales to natural datasets such as ImageNet and is applicable to deep neural networks (DNNs). The most relevant prior work is a variant of transfer attacks in which the training set needed to learn the substitute model is replaced by a synthetic dataset (Papernot et al., 2017b). This synthetic dataset is generated by the adversary alongside the training of the substitute; the labels for each synthetic sample are drawn from the black-box model. While this approach works well on datasets for which the intra-class variability is low (such as MNIST) it has yet to be shown that it scales to more complex natural datasets such as CIFAR or ImageNet. Other decision-based attacks are specific to linear or convex-inducing classifiers (Dalvi et al., 2004; Lowd & Meek, 2005; Nelson et al., 2012) and are not applicable to other machine learning models. The work by (Biggio et al., 2013) basically stands between transfer attacks and decision-based attacks in that the substitute model is trained on a dataset for which the labels have been observed from the black-box model. This attack still requires knowledge about the data distribution on which the black-box models was trained on and so we don’t consider it a pure decision-based attack. Finally, some naive attacks such as a line-search along a random direction away from the original sample can qualify as decision-based attacks but they induce large and very visible perturbations that are orders of magnitude larger than typical gradient-based, score-based or transfer-based attacks. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            573
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Throughout the paper we focus on the threat scenario in which the adversary aims to change the decision of a model (either targeted or untargeted) for a particular input sample by inducing a minimal perturbation to the sample. The adversary can observe the final decision of the model for arbitrary inputs and it knows at least one perturbation, however large, for which the perturbed sample is adversarial. ",
+        "bbox": [
+            176,
+            580,
+            825,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The contributions of this paper are as follows: ",
+        "bbox": [
+            176,
+            656,
+            473,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• We emphasise decision-based attacks as an important category of adversarial attacks that are highly relevant for real-world applications and important to gauge model robustness. We introduce the first effective decision-based attack that scales to complex machine learning models and natural datasets. The Boundary Attack is (1) conceptually surprisingly simple, (2) extremely flexible, (3) requires little hyperparameter tuning and (4) is competitive with the best gradient-based attacks in both targeted and untargeted computer vision scenarios.   \nWe show that the Boundary Attack is able to break previously suggested defence mechanisms like defensive distillation. We demonstrate the practical applicability of the Boundary Attack on two black-box machine learning models for brand and celebrity recognition available on Clarifai.com. ",
+        "bbox": [
+            215,
+            684,
+            825,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1.1 NOTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            287,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Throughout the paper we use the following notation: $^ o$ refers to the original input (e.g. an image), $\\begin{array} { r } { y = \\bar { F } ( o ) } \\end{array}$ refers to the full prediction of the model $F ( \\cdot )$ (e.g. logits or probabilities), $y _ { m a x }$ is the ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "predicted label (e.g. class-label). Similarly, $\\tilde { o }$ refers to the adversarially perturbed image, $\\tilde { o } ^ { k }$ refers to the perturbed image at the $k$ -th step of an attack algorithm. Vectors are denoted in bold. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2 BOUNDARY ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            151,
+            375,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The basic intuition behind the boundary attack algorithm is depicted in Figure 2: the algorithm is initialized from a point that is already adversarial and then performs a random walk along the boundary between the adversarial and the non-adversarial region such that (1) it stays in the adversarial region and (2) the distance towards the target image is reduced. In other words we perform rejection sampling with a suitable proposal distribution $\\mathcal { P }$ to find progressively smaller adversarial perturbations according to a given adversarial criterion $c ( . )$ . The basic logic of the algorithm is described in Algorithm 1, each individual building block is detailed in the next subsections. ",
+        "bbox": [
+            173,
+            183,
+            825,
+            280
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Data: original image o, adversarial criterion $c ( . )$ , decision of model $d ( . )$   \nResult: adversarial example $\\tilde { o }$ such that the distance $d ( \\pmb { o } , \\tilde { \\pmb { o } } ) = \\lVert \\pmb { o } - \\tilde { \\pmb { o } } \\rVert _ { 2 } ^ { 2 }$ is minimized   \ninitialization: $k = 0$ , $\\tilde { \\sigma } ^ { 0 } \\sim \\mathcal { U } ( 0 , 1 )$ s.t. $\\tilde { \\bullet } ^ { 0 }$ is adversarial;   \nwhile $k <$ maximum number of steps do draw random perturbation from proposal distribution $\\eta _ { k } \\sim \\mathcal { P } ( \\tilde { o } ^ { k - 1 } )$ ; if $\\tilde { o } ^ { k - 1 } + \\eta _ { k }$ is adversarial then set $\\tilde { \\pmb { o } } ^ { k } = \\tilde { \\pmb { o } } ^ { k - 1 } + \\eta _ { k }$ ; else set $\\tilde { o } ^ { k } = \\tilde { o } ^ { k - 1 }$ ; end $k = k + 1$   \nend ",
+        "bbox": [
+            174,
+            295,
+            745,
+            469
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Minimal version of the Boundary Attack. ",
+        "bbox": [
+            315,
+            469,
+            681,
+            484
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1 INITIALISATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            510,
+            326,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The Boundary Attack needs to be initialized with a sample that is already adversarial3. In an untargeted scenario we simply sample from a maximum entropy distribution given the valid domain of the input. In the computer vision applications below, where the input is constrained to a range of [0, 255] per pixel, we sample each pixel in the initial image $\\mathbf { \\tilde { o } ^ { 0 } }$ from a uniform distribution $\\mathcal { U } ( 0 , \\bar { 2 } 5 5 )$ . We reject samples that are not adversarial. In a targeted scenario we start from any sample that is classified by the model as being from the target class. ",
+        "bbox": [
+            174,
+            536,
+            825,
+            619
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 PROPOSAL DISTRIBUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            637,
+            393,
+            651
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The efficiency of the algorithm crucially depends on the proposal distribution $\\mathcal { P }$ , i.e. which random directions are explored in each step of the algorithm. The optimal proposal distribution will generally depend on the domain and / or model to be attacked, but for all vision-related problems tested here a very simple proposal distribution worked surprisingly well. The basic idea behind this proposal distribution is as follows: in the $k$ -th step we want to draw perturbations $\\eta ^ { k }$ from a maximum entropy distribution subject to the following constraints: ",
+        "bbox": [
+            173,
+            662,
+            825,
+            746
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. The perturbed sample lies within the input domain, ",
+        "bbox": [
+            214,
+            756,
+            568,
+            771
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/348e347ad0a2c0dcd2d0a2cc0426e52dac30f4ac56252c0418e77d8bf07ee017.jpg",
+        "text": "$$\n\\tilde { o } _ { i } ^ { k - 1 } + \\eta _ { i } ^ { k } \\in [ 0 , 2 5 5 ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            775,
+            602,
+            795
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2. The perturbation has a relative size of $\\delta$ , ",
+        "bbox": [
+            214,
+            799,
+            496,
+            814
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ae2a469cc5bde9d87c2658a147365fcf69f87e4f1a52170e248fe96dbb1fb7ec.jpg",
+        "text": "$$\n\\left\\| \\pmb { \\eta } ^ { k } \\right\\| _ { 2 } = \\delta \\cdot d ( \\mathbf { o } , \\tilde { \\mathbf { o } } ^ { \\mathbf { k } - \\mathbf { 1 } } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            444,
+            818,
+            611,
+            839
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3. The perturbation reduces the distance of the perturbed image towards the original input by a relative amount $\\epsilon$ , ",
+        "bbox": [
+            209,
+            843,
+            823,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a97013d8f560c84fb463e8588ce8246d2dae234258e38c18d3774901971b67f4.jpg",
+        "text": "$$\nd ( { \\bf o } , \\tilde { \\bf o } ^ { { \\bf k } - 1 } ) - d ( { \\bf o } , \\tilde { \\bf o } ^ { { \\bf k } - 1 } + \\eta ^ { k } ) = \\epsilon \\cdot d ( { \\bf o } , \\tilde { \\bf o } ^ { { \\bf k } - 1 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            873,
+            691,
+            893
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9a81d4b166c0bc0a33a374cca7d988a2eea34ac136d9734d6e84454672850a0.jpg",
+        "image_caption": [
+            "Figure 2: (Left) In essence the Boundary Attack performs rejection sampling along the boundary between adversarial and non-adversarial images. (Center) In each step we draw a new random direction by (#1) drawing from an iid Gaussian and projecting on a sphere, and by (#2) making a small move towards the target image. (Right) The two step-sizes (orthogonal and towards the original input) are dynamically adjusted according to the local geometry of the boundary. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            102,
+            826,
+            297
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In practice it is difficult to sample from this distribution, and so we resort to a simpler heuristic: first, we sample from an iid Gaussian distribution $\\eta _ { i } ^ { k } \\sim \\mathcal { N } ( 0 , 1 )$ and then rescale and clip the sample such that (1) and (2) hold. In a second step we project $\\eta ^ { k }$ onto a sphere around the original image $^ o$ such that $d ( o , \\tilde { o } ^ { k - 1 } + \\eta ^ { k } ) = d ( o , \\tilde { o } ^ { k - 1 } )$ and (1) hold. We denote this as the orthogonal perturbation and use it later for hyperparameter tuning. In the last step we make a small movement towards the original image such that (1) and (3) hold. For high-dimensional inputs and small $\\delta , \\epsilon$ the constraint (2) will also hold approximately. ",
+        "bbox": [
+            174,
+            415,
+            825,
+            515
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 ADVERSARIAL CRITERION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            534,
+            398,
+            546
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "A typical criterion by which an input is classified as adversarial is misclassification, i.e. whether the model assigns the perturbed input to some class different from the class label of the original input. Another common choice is targeted misclassification for which the perturbed input has to be classified in a given target class. Other choices include top-k misclassification (the top-k classes predicted for the perturbed input do not contain the original class label) or thresholds on certain confidence scores. Outside of computer vision many other choices exist such as criteria on the worderror rates. In comparison to most other attacks, the Boundary Attack is extremely flexible with regards to the adversarial criterion. It basically allows any criterion (including non-differentiable ones) as long as for that criterion an initial adversarial can be found (which is trivial in most cases). ",
+        "bbox": [
+            174,
+            559,
+            825,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.4 HYPERPARAMETER ADJUSTMENT ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            703,
+            444,
+            717
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The Boundary Attack has only two relevant parameters: the length of the total perturbation $\\delta$ and the length of the step $\\epsilon$ towards the original input (see Fig. 2). We adjust both parameters dynamically according to the local geometry of the boundary. The adjustment is inspired by Trust Region methods. In essence, we first test whether the orthogonal perturbation is still adversarial. If this is true, then we make a small movement towards the target and test again. The orthogonal step tests whether the step-size is small enough so that we can treat the decision boundary between the adversarial and the non-adversarial region as being approximately linear. If this is the case, then we expect around $50 \\%$ of the orthogonal perturbations to still be adversarial. If this ratio is much lower, we reduce the step-size $\\delta$ , if it is close to $50 \\%$ or higher we increase it. If the orthogonal perturbation is still adversarial we add a small step towards the original input. The maximum size of this step depends on the angle of the decision boundary in the local neighbourhood (see also Figure 2). If the success rate is too small we decrease $\\epsilon$ , if it is too large we increase it. Typically, the closer we get to the original image, the flatter the decision boundary becomes and the smaller $\\epsilon$ has to be to still make progress. The attack is converged whenever $\\epsilon$ converges to zero. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 COMPARISON WITH OTHER ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            509,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We quantify the performance of the Boundary Attack on three different standard datasets: MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky & Hinton, 2009) and ImageNet-1000 (Deng et al., 2009). To make the comparison with previous results as easy and transparent as possible, we here use the same MNIST and CIFAR networks as Carlini & Wagner (2016a)4. In a nutshell, both the MNIST and CIFAR model feature nine layers with four convolutional layers, two max-pooling layers and two fully-connected layers. For all details, including training parameters, we refer the reader to (Carlini & Wagner, 2016a). On ImageNet we use the pretrained networks VGG-19 (Simonyan & Zisserman, 2014), ResNet-50 (He et al., 2015) and Inception-v3 (Szegedy et al., 2015) provided by Keras5. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            258
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate the Boundary Attack in two settings: an (1) untargeted setting in which the adversarial perturbation flips the label of the original sample to any other label, and a (2) targeted setting in which the adversarial flips the label to a specific target class. In the untargeted setting we compare the Boundary Attack against three gradient-based attack algorithms: ",
+        "bbox": [
+            176,
+            265,
+            825,
+            321
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Fast-Gradient Sign Method (FGSM). FGSM is among the simplest and most widely used untargeted adversarial attack methods. In a nutshell, FGSM computes the gradient ${ \\textbf { 0 } } =$ $\\nabla _ { o } \\mathcal { L } ( o , c )$ that maximizes the loss $\\mathcal { L }$ for the true class-label $c$ and then seeks the smallest $\\epsilon$ for which $\\mathbf { \\omega } _ { o + \\epsilon } . \\mathbf { \\omega } _ { g }$ is still adversarial. We use the implementation in Foolbox 0.10.0 (Rauber et al., 2017). DeepFool. DeepFool is a simple yet very effective attack. In each iteration it computes for each class $\\ell \\neq \\ell _ { 0 }$ the minimum distance $d ( \\ell , \\ell _ { 0 } )$ that it takes to reach the class boundary by approximating the model classifier with a linear classifier. It then makes a corresponding step in the direction of the class with the smallest distance. We use the implementation in Foolbox 0.10.0 (Rauber et al., 2017). Carlini & Wagner. The attack by Carlini & Wagner (Carlini & Wagner, 2016a) is essentially a refined iterative gradient attack that uses the Adam optimizer, multiple starting points, a tanh-nonlinearity to respect box-constraints and a max-based adversarial constraint function. We use the original implementation provided by the authors with all hyperparameters left at their default values4. ",
+        "bbox": [
+            214,
+            333,
+            825,
+            553
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the success of each attack we use the following metric: let $\\pmb { \\eta } _ { A , M } ( \\pmb { o } _ { i } ) \\in \\mathbb { R } ^ { N }$ be the adversarial perturbation that the attack $A$ finds on model $M$ for the $i$ -th sample $\\mathbf { o } _ { i }$ . The total score $\\mathcal { S } _ { A }$ for $A$ is the median squared L2-distance across all samples, ",
+        "bbox": [
+            176,
+            564,
+            821,
+            607
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/854e1a35e347ec241ff85371dbff001b24d383cad711fcf1fd55f2565c035d42.jpg",
+        "text": "$$\n\\mathcal { S } _ { A } ( M ) = \\mathrm { m e d i a n } \\left( \\frac { 1 } { N } \\left. \\pmb { \\eta } _ { A , M } ( \\pmb { o } _ { i } ) \\right. _ { 2 } ^ { 2 } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            613,
+            635,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For MNIST and CIFAR we evaluate 1000 randomly drawn samples from the validation set, for ImageNet we use 250 images. ",
+        "bbox": [
+            173,
+            652,
+            823,
+            681
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 UNTARGETED ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            698,
+            370,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the untargeted setting an adversarial is any image for which the predicted label is different from the label of the original image. We show adversarial samples synthesized by the Boundary Attack for each dataset in Figure 3. The score (4) for each attack and each dataset is as follows: ",
+        "bbox": [
+            174,
+            723,
+            825,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/15d735d7a955403f256629b55a9a4ff0addd16794b4cb1e58d110033ac569452.jpg",
+        "table_caption": [
+            "ImageNet "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Attack Type</td><td>MNIST</td><td>CIFAR</td><td>VGG-19</td><td>ResNet-50</td><td>Inception-v3</td></tr><tr><td>FGSM</td><td>gradient-based</td><td>4.2e-02</td><td>2.5e-05</td><td>1.0e-06</td><td>1.0e-06</td><td>9.7e-07</td></tr><tr><td>DeepFool</td><td>gradient-based</td><td>4.3e-03</td><td>5.8e-06</td><td>1.9e-07</td><td>7.5e-08</td><td>5.2e-08</td></tr><tr><td>Carlini &amp; Wagner</td><td>gradient-based</td><td>2.2e-03</td><td>7.5e-06</td><td>5.7e-07</td><td>2.2e-07</td><td>7.6e-08</td></tr><tr><td>Boundary (ours)</td><td>decision-based</td><td>3.6e-03</td><td>5.6e-06</td><td>2.9e-07</td><td>1.0e-07</td><td>6.5e-08</td></tr></table>",
+        "bbox": [
+            174,
+            801,
+            823,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/eeb7e498a6f3dda6b80f2fdd07715a54125dc071e8a27bf1b9e1a9682e877d9e.jpg",
+        "image_caption": [
+            "Figure 3: Adversarial examples generated by the Boundary Attack for an MNIST, CIFAR and ImageNet network. For MNIST, the difference shows positive (blue) and negative (red) changes. For CIFAR and ImageNet, we take the norm across color channels. All differences have been scaled up for improved visibility. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            98,
+            820,
+            258
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/224fd7d916d70367db5cbec645c4cb5aa8c9276b5fe4430a32d62d409dd41f11.jpg",
+        "image_caption": [
+            "Figure 4: Example of an untargeted attack. Here the goal is to synthesize an image that is as close as possible (in L2-metric) to the original image while being misclassified (the original image is correctly classified). For each image we report the total number of model calls (predictions) until that point (above the image) and the mean squared error between the adversarial and the original (below the image). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            353,
+            820,
+            515
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Despite its simplicity the Boundary Attack is competitive with gradient-based attacks in terms of the minimal adversarial perturbations and very stable against the choice of the initial point (Figure 5). This finding is quite remarkable given that gradient-based attacks can fully observe the model whereas the Boundary Attack is severely restricted to the final class prediction. To compensate for this lack of information the Boundary Attack needs many more iterations to converge. As a rough measure for the run-time of an attack independent of the quality of its implementation we tracked the number of forward passes (predictions) and backward passes (gradients) through the network requested by each of the attacks to find an adversarial for ResNet-50: averaged over 20 samples and under the same conditions as before, DeepFool needs about 7 forward and 37 backward passes, the Carlini & Wagner attack requires 16.000 forward and the same number of backward passes, and the Boundary Attack uses 1.200.000 forward passes but zero backward passes. While that (unsurprisingly) makes the Boundary Attack more expensive to run it is important to note that the Boundary Attacks needs much fewer iterations if one is only interested in imperceptible perturbations, see figures 4 and 6. ",
+        "bbox": [
+            173,
+            636,
+            825,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 TARGETED ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            853,
+            348,
+            867
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We can also apply the Boundary Attack in a targeted setting. In this case we initialize the attack from a sample of the target class that is correctly identified by the model. A sample trajectory from the starting point to the original sample is shown in Figure 7. After around $1 0 ^ { 4 }$ calls to the model the perturbed image is already clearly identified as a cat by humans and contains no trace of the Dalmatian dog, as which the image is still classified by the model. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/a182715ad2d667ed65ca2ebb2779a3bcb68058efa6b45bdb4d123f50179eb937.jpg",
+        "image_caption": [
+            "Figure 5: Adversarial perturbation (difference between the adversarial and the original image) for ten repetitions of the Boundary Attack on the same image. There are basically two different minima with similar distance (first row and second row) to which the Boundary Attack converges. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            552,
+            241
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6a777ffa8fb8799bffa6b639846bc5e2222923e9088233bf6dffdd0db0a6b1f.jpg",
+        "image_caption": [
+            "Figure 6: Distance between adversarial and original image over number of model calls for 12 different images (until convergence). Very few steps are already sufficient to get almost imperceptible perturbations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            575,
+            103,
+            820,
+            239
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/3762b35219c7d357b48af44610d0275cae626e52f01443af83b519d540c06334.jpg",
+        "image_caption": [
+            "Figure 7: Example of a targeted attack. Here the goal is to synthesize an image that is as close as possible (in L2-metric) to a given image of a tiger cat (2nd row, right) but is classified as a dalmatian dog. For each image we report the total number of model calls (predictions) until that point. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            363,
+            825,
+            501
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            601,
+            823,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to compare the Boundary Attack to Carlini & Wagner we define the target target label for each sample in the following way: on MNIST and CIFAR a sample with label $\\ell$ gets the target label $\\ell + 1$ modulo 10. On ImageNet we draw the target label randomly but consistent across attacks. The results are as follows: ",
+        "bbox": [
+            173,
+            635,
+            825,
+            690
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/16ddf00a6c26f914b691bb7924461fc8257200c15f41def47136baae93b77590.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Attack Type</td><td>MNIST</td><td>CIFAR</td><td>VGG-19</td></tr><tr><td>Carlini &amp;Wagner</td><td>gradient-based</td><td>4.8e-03</td><td>3.0e-05</td><td>5.7e-06</td></tr><tr><td>Boundary (ours)</td><td>decision-based</td><td>6.5e-03</td><td>3.3e-05</td><td>9.9e-06</td></tr></table>",
+        "bbox": [
+            174,
+            710,
+            825,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 THE IMPORTANCE OF DECISION-BASED ATTACKS TO EVALUATE MODEL ROBUSTNESS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            797,
+            730,
+            830
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As discussed in the introduction, many attack methods are straight-forward to defend against. One common nuisance is gradient masking in which a model is implicitely or explicitely modified to yield masked gradients. An interesting example is the saturated sigmoid network (Nayebi & Ganguli, 2017) in which an additional regularization term leads the sigmoid activations to saturate, which in turn leads to vanishing gradients and failing gradient-based attacks (Brendel & Bethge, 2017). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Another example is defensive distillation (Papernot et al., 2016). In a nutshell defensive distillation uses a temperature-augmented softmax of the type ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "equation",
+        "img_path": "images/20f7695db05025ce644576bdf1b72cc315a800daaa9008e364438faef6a93350.jpg",
+        "text": "$$\ns o f t m a x ( x , T ) _ { i } = \\frac { e ^ { x _ { i } / T } } { \\sum _ { j } e ^ { x _ { j } / T } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            397,
+            138,
+            601,
+            178
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "and works as follows: ",
+        "bbox": [
+            174,
+            183,
+            318,
+            198
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "1. Train a teacher network as usual but with temperature $T$ .   \n2. Train a distilled network—with the same architecture as the teacher—on the softmax outputs of the teacher. Both the distilled network and the teacher use temperature $T$ .   \n3. Evaluate the distilled network at temperature $T = 1$ at test time. ",
+        "bbox": [
+            207,
+            209,
+            823,
+            276
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Initial results were promising: the success rate of gradient-based attacks dropped from close to $100 \\%$ down to $0 . 5 \\%$ . It later became clear that the distilled networks only appeared to be robust because they masked their gradients of the cross-entropy loss (Carlini & Wagner, 2016b): as the temperature of the softmax is decreased at test time, the input to the softmax increases by a factor of $T$ and so the probabilities saturate at 0 and 1. This leads to vanishing gradients of the cross-entropy loss w.r.t. to the input on which gradient-based attacks rely. If the same attacks are instead applied to the logits the success rate recovers to almost $1 0 0 \\%$ (Carlini & Wagner, 2016a). ",
+        "bbox": [
+            174,
+            287,
+            825,
+            385
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Decision-based attacks are immune to such defences. To demonstrate this we here apply the Boundary Attack to two distilled networks trained on MNIST and CIFAR. The architecture is the same as in section 3 and we use the implementation and training protocol by (Carlini & Wagner, 2016a) which is available at https://github.com/carlini/nn_robust_attacks. Most importantly, we do not operate on the logits but provide only the class label with maximum probability to the Boundary Attack. The results are as follows: ",
+        "bbox": [
+            173,
+            392,
+            825,
+            476
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e0f2b5468a317f65b2a4abd815a0fba69c9adf644595628da3a41e5a20a09e68.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td rowspan=\"2\">Attack Type</td><td colspan=\"2\">MNIST</td><td colspan=\"2\">CIFAR</td></tr><tr><td>standard</td><td>distilled</td><td>standard</td><td>distilled</td></tr><tr><td>FGSM</td><td>gradient-based</td><td>4.2e-02</td><td>fails</td><td>2.5e-05</td><td>fails</td></tr><tr><td>Boundary (ours)</td><td>decision-based</td><td>3.6e-03</td><td>4.2e-03</td><td>5.6e-06</td><td>1.3e-05</td></tr></table>",
+        "bbox": [
+            169,
+            497,
+            828,
+            558
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The size of the adversarial perturbations that the Boundary Attack finds is fairly similar for the distilled and the undistilled network. This demonstrates that defensive distillation does not significantly increase the robustness of network models and that the Boundary Attack is able to break defences based on gradient masking. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            630
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 ATTACKS ON REAL-WORLD APPLICATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            651,
+            558,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In many real-world machine learning applications the attacker has no access to the architecture or the training data but can only observe the final decision. This is true for security systems (e.g. face identification), autonomous cars or speech recognition systems like Alexa or Cortana. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            723
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section we apply the Boundary Attack to two models of the cloud-based computer vision API by Clarifai6. The first model identifies brand names in natural images and recognizes over 500 brands. The second model identifies celebrities and can recognize over 10.000 individuals. Multiple identifications per image are possible but we only consider the one with the highest confidence score. It is important to note that Clarifai does provide confidence scores for each identified class (but not for all possible classes). However, in our experiments we do not provide this confidence score to the Boundary Attack. Instead, our attack only receives the name of the identified object (e.g. Pepsi or Verizon in the brand-name detection task). ",
+        "bbox": [
+            174,
+            729,
+            825,
+            842
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We selected several samples of natural images with clearly visible brand names or portraits of celebrities. We then make a square crop and resize the image to $1 0 0 \\times 1 0 0$ pixels. For each sample we make sure that the brand or the celebrity is clearly visible and that the corresponding Clarifai model correctly identifies the content. The adversarial criterion was misclassification, i.e. Clarifai should report a different brand / celebrity or None on the adversarially perturbed sample. ",
+        "bbox": [
+            174,
+            849,
+            825,
+            890
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7839d3f976c5105c19b1e4c52f53e928122f89340e84a1444ce3924a0bbd7dd.jpg",
+        "image_caption": [
+            "Figure 8: Adversarial examples generated by the Boundary Attack for two black-box models by Clarifai for brand-detection (left side) and celebrity detection (right side). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            818,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            311,
+            823,
+            340
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We show five samples for each model alongside the adversarial image generated by the Boundary Attack in Figure 8. We generally observed that the Clarifai models were more difficult to attack than ImageNet models like VGG-19: while for some samples we did succeed to find adversarial perturbations of the same order $( 1 e ^ { - 7 } )$ as in section 3 (e.g. for Shell or $S A P$ ), most adversarial perturbations were on the order of $1 e ^ { - 2 }$ to $1 e ^ { - 3 }$ resulting in some slightly noticeable noise in some adversarial examples. Nonetheless, for most samples the original and the adversarial image are close to being perceptually indistinguishable. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            445
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 DISCUSSION & OUTLOOK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            483,
+            419,
+            500
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we emphasised the importance of a mostly neglected category of adversarial attacks— decision-based attacks—that can find adversarial examples in models for which only the final decision can be observed. We argue that this category is important for three reasons: first, attacks in this class are highly relevant for many real-world deployed machine learning systems like autonomous cars for which the internal decision making process is unobservable. Second, attacks in this class do not rely on substitute models that are trained on similar data as the model to be attacked, thus making real-world applications much more straight-forward. Third, attacks in this class have the potential to be much more robust against common deceptions like gradient masking, intrinsic stochasticity or robust training. ",
+        "bbox": [
+            174,
+            526,
+            825,
+            652
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also introduced the first effective attack in this category that is applicable to general machine learning algorithms and complex natural datasets: the Boundary Attack. At its core the Boundary Attack follows the decision boundary between adversarial and non-adversarial samples using a very simple rejection sampling algorithm in conjunction with a simple proposal distribution and a dynamic step-size adjustment inspired by Trust Region methods. Its basic operating principle— starting from a large perturbation and successively reducing it—inverts the logic of essentially all previous adversarial attacks. Besides being surprisingly simple, the Boundary attack is also extremely flexible in terms of the possible adversarial criteria and performs on par with gradient-based attacks on standard computer vision tasks in terms of the size of minimal perturbations. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The mere fact that a simple constrained iid Gaussian distribution can serve as an effective proposal perturbation for each step of the Boundary attack is surprising and sheds light on the brittle information processing of current computer vision architectures. Nonetheless, there are many ways in which the Boundary attack can be made even more effective, in particular by learning a suitable proposal distribution for a given model or by conditioning the proposal distribution on the recent history of successful and unsuccessful proposals. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Decision-based attacks will be highly relevant to assess the robustness of machine learning models and to highlight the security risks of closed-source machine learning systems like autonomous cars. We hope that the Boundary attack will inspire future work in this area. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            326,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by the Carl Zeiss Foundation (0563-2.8/558/3), the Bosch Forschungsstiftung (Stifterverband, T113/30057/17), the International Max Planck Research School for Intelligent Systems (IMPRS-IS), the German Research Foundation (DFG, CRC 1233, Robust Vision: Inference Principles and Neural Mechanisms) and the Intelligence Advanced Research Projects Activity (IARPA) via Department of Interior/Interior Business Center (DoI/IBC) contract number D16PC00003. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright annotation thereon. Disclaimer: The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of IARPA, DoI/IBC, or the U.S. Government. ",
+        "bbox": [
+            174,
+            127,
+            825,
+            266
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            287,
+            285,
+            303
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013. ",
+        "bbox": [
+            174,
+            310,
+            826,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wieland Brendel and Matthias Bethge. Comment on “biologically inspired protection of deep networks from adversarial attacks”. CoRR, abs/1704.01547, 2017. URL http://arxiv.org/ abs/1704.01547. ",
+        "bbox": [
+            173,
+            375,
+            821,
+            417
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David A. Wagner. Towards evaluating the robustness of neural networks. CoRR, abs/1608.04644, 2016a. URL http://arxiv.org/abs/1608.04644. ",
+        "bbox": [
+            171,
+            426,
+            823,
+            455
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David A. Wagner. Defensive distillation is not robust to adversarial examples. CoRR, abs/1607.04311, 2016b. URL http://arxiv.org/abs/1607.04311. ",
+        "bbox": [
+            173,
+            463,
+            825,
+            493
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. CoRR, abs/1708.03999, 2017. URL http://arxiv.org/abs/1708.03999. ",
+        "bbox": [
+            173,
+            501,
+            821,
+            544
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Moustapha Cisse, Yossi Adi, Natalia Neverova, and Joseph Keshet. Houdini: Fooling deep structured prediction models. CoRR, abs/1707.05373, 2017. URL http://arxiv.org/abs/ 1707.05373. ",
+        "bbox": [
+            174,
+            551,
+            821,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nilesh Dalvi, Pedro Domingos, Mausam, Sumit Sanghai, and Deepak Verma. Adversarial classification. In Proceedings of the Tenth ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’04, pp. 99–108, New York, NY, USA, 2004. ACM. ISBN 1-58113-888-1. doi: 10.1145/1014052.1014066. URL http://doi.acm.org/10.1145/ 1014052.1014066. ",
+        "bbox": [
+            171,
+            603,
+            825,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. In Computer Vision and Pattern Recognition, 2009. CVPR 2009. IEEE Conference on, pp. 248–255. IEEE, 2009. ",
+        "bbox": [
+            173,
+            681,
+            821,
+            724
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jamie Hayes and George Danezis. Machine learning as an adversarial service: Learning blackbox adversarial examples. CoRR, abs/1708.05207, 2017. URL http://arxiv.org/abs/ 1708.05207. ",
+        "bbox": [
+            173,
+            732,
+            823,
+            775
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CoRR, abs/1512.03385, 2015. URL http://arxiv.org/abs/1512.03385. ",
+        "bbox": [
+            173,
+            784,
+            821,
+            813
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009. ",
+        "bbox": [
+            173,
+            820,
+            820,
+            849
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian J. Goodfellow, and Samy Bengio. Adversarial examples in the physical world. CoRR, abs/1607.02533, 2016. URL http://arxiv.org/abs/1607.02533. ",
+        "bbox": [
+            174,
+            858,
+            823,
+            887
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. CoRR, abs/1611.02770, 2016. URL http://arxiv.org/abs/ 1611.02770. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Daniel Lowd and Christopher Meek. Adversarial learning. In Proceedings of the Eleventh ACM SIGKDD International Conference on Knowledge Discovery in Data Mining, KDD ’05, pp. 641– 647, New York, NY, USA, 2005. ACM. ISBN 1-59593-135-X. doi: 10.1145/1081870.1081950. URL http://doi.acm.org/10.1145/1081870.1081950. ",
+        "bbox": [
+            179,
+            154,
+            821,
+            209
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Lu, Theerasit Issaranon, and David A. Forsyth. Safetynet: Detecting and rejecting adversarial examples robustly. CoRR, abs/1704.00103, 2017. URL http://arxiv.org/abs/1704. 00103. ",
+        "bbox": [
+            173,
+            217,
+            823,
+            258
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. CoRR, abs/1511.04599, 2015. URL http: //arxiv.org/abs/1511.04599. ",
+        "bbox": [
+            174,
+            267,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nina Narodytska and Shiva Prasad Kasiviswanathan. Simple black-box adversarial perturbations for deep networks. CoRR, abs/1612.06299, 2016. URL http://arxiv.org/abs/1612. 06299. ",
+        "bbox": [
+            173,
+            318,
+            823,
+            359
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aran Nayebi and Surya Ganguli. Biologically inspired protection of deep networks from adversarial attacks. CoRR, abs/1703.09202, 2017. URL http://arxiv.org/abs/1703.09202. ",
+        "bbox": [
+            168,
+            367,
+            825,
+            396
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Blaine Nelson, Benjamin I. P. Rubinstein, Ling Huang, Anthony D. Joseph, Steven J. Lee, Satish Rao, and J. D. Tygar. Query strategies for evading convex-inducing classifiers. J. Mach. Learn. Res., 13:1293–1332, May 2012. ISSN 1532-4435. URL http://dl.acm.org/citation. cfm?id=2188385.2343688. ",
+        "bbox": [
+            173,
+            404,
+            823,
+            460
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick D. McDaniel, Somesh Jha, Matt Fredrikson, Z. Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. CoRR, abs/1511.07528, 2015. URL http://arxiv.org/abs/1511.07528. ",
+        "bbox": [
+            174,
+            467,
+            823,
+            511
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Xi Wu, Somesh Jha, and Ananthram Swami. Distillation as a defense to adversarial perturbations against deep neural networks. In Security and Privacy (SP), 2016 IEEE Symposium on, pp. 582–597. IEEE, 2016. ",
+        "bbox": [
+            173,
+            517,
+            823,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, pp. 506–519. ACM, 2017a. ",
+        "bbox": [
+            173,
+            566,
+            825,
+            611
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z. Berkay Celik, and Ananthram Swami. Practical black-box attacks against machine learning. In Proceedings of the 2017 ACM on Asia Conference on Computer and Communications Security, ASIA CCS ’17, pp. 506–519, New York, NY, USA, 2017b. ACM. ISBN 978-1-4503-4944-4. doi: 10.1145/3052973.3053009. URL http://doi.acm.org/10.1145/3052973.3053009. ",
+        "bbox": [
+            173,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonas Rauber, Wieland Brendel, and Matthias Bethge. Foolbox v0.8.0: A python toolbox to benchmark the robustness of machine learning models. CoRR, abs/1707.04131, 2017. URL http://arxiv.org/abs/1707.04131. ",
+        "bbox": [
+            173,
+            695,
+            821,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            173,
+            744,
+            821,
+            773
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. CoRR, abs/1312.6199, 2013. URL http://arxiv.org/abs/1312.6199. ",
+        "bbox": [
+            174,
+            781,
+            823,
+            824
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jonathon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. CoRR, abs/1512.00567, 2015. URL http://arxiv.org/abs/1512.00567. ",
+        "bbox": [
+            174,
+            830,
+            821,
+            875
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramer, Alexey Kurakin, Nicolas Papernot, Dan Boneh, and Patrick McDaniel. Ensemble adversarial training: Attacks and defenses. CoRR, abs/1705.07204, May 2017. URL http: //arxiv.org/abs/1705.07204. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 11
+    }
+]

parse/train/ki4eJ1fSJNq/ki4eJ1fSJNq.md

@@ -0,0 +1,457 @@
+# Fitting large mixture models using stochastic component selection
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Traditional methods for unsupervised learning of finite mixture models require to   
+2 evaluate the likelihood of all components of the mixture. This becomes computa  
+3 tionally prohibitive when the number of components is large, as it is, for example,   
+4 in the sum-product (transform) networks. As a remedy, we propose an approach   
+5 combining the expectation maximization and the Metropolis-Hastings algorithm   
+6 to evaluate only a small number of, stochastically sampled, components, thus   
+7 substantially reducing the computational cost. We put emphasis on generality of   
+8 our method, equipping it with the ability to train both shallow and deep mixture   
+9 models which involve complex, and possibly nonlinear, transformations. The   
+10 performance of our method is illustrated in a variety of synthetic and real-data   
+11 contexts, considering deep models, such as mixtures of normalizing flows and   
+12 sum-product (transform) networks.
+
+# 13 1 Introduction
+
+14 Finite mixture models [40] constitute a fundamental class of density estimation models. They   
+15 have been successfully applied in diverse fields, including bioinformatics [49], econometrics [10],   
+16 engineering [33], etc. A mixture model relies on a weighted sum of probability distributions—here   
+17 referred to as components—to cluster $N$ unlabelled datapoints into $K$ categories. The traditional   
+18 maximum likelihood techniques train the model by optimizing either (i) the marginal likelihood via   
+19 gradient-descent [50] or (ii) the evidence lower bound via variational methods [4], including the   
+20 expectation-maximization (EM) [13]. The dependence structure among approximate, variational,   
+21 distributions then ranges from the fully independent (mean-field) [25] to fully dependent [30]. The   
+22 sampling-based techniques target the posterior distribution using sequential Monte Carlo [9] or   
+23 Markov chain Monte Carlo [52], e.g. via the Gibbs [34] or Metropolis-Hastings sampling [38]. The   
+24 computational cost of these methods typically scales with $\mathcal { O } ( T K N D )$ operations, where $N$ and $K$   
+25 are defined above, $T$ is the number of iterations and $D$ is the dimension of data.   
+26 Various methods to decrease the computational cost via any factor in $\mathcal { O } ( T K N D )$ have been proposed.   
+27 $T$ can be lowered by proper initialization, e.g. the optimal seeding [5]; an efficient step-size schedule,   
+28 e.g. the line-search [58]; or increased estimation precision, e.g. the variance reduction [8]. $N$ is often   
+29 reduced using the coreset methods, which approximate the original dataset by a weighted dataset   
+30 such that the exact and approximate marginal likelihoods are close. The weighted variants of the   
+31 variational [17, 59, 6] and sampling-based [39] methods then process the coresets. Reducing $D$ relies   
+32 on the compression of data into smaller representations via random projections [53, 2], which is   
+33 achieved in two ways: (i) each data item is projected into an individual representation [11]; (ii) all   
+34 data items are projected into an overall representation, commonly referred to as sketch [28, 22].   
+35 Nevertheless, all the aforementioned techniques—including those with reduced computational cost—   
+36 evaluate all $K$ components. This is very demanding for large models, and the problem is even more   
+37 severe for mixtures involving intricate models, such as neural networks [21, 42], Gaussian processes   
+38 [57], normalizing flows [48]; or deep mixtures, including sum-product (transform) networks [45, 47],   
+39 deep Gaussian mixture models [55], etc. In spite of this, a little attention has been paid to the design   
+40 of algorithms which does not evaluate all $K$ components. The notable exceptions are the sparse EM   
+41 algorithm [24] and the truncated variational EM algorithm [18], see Table 1 and Section 5 for details.   
+42 Moreover, the methods are mostly tailored for a specific class of mixture models, e.g. the Gaussian   
+43 mixture models.
+
+Table 1: The computational features of various EM algorithms. We compare whether the methods (i) perform the computations with a reduced number of data (minibatching), (ii) update a lower number of statistics, (iii) make less evaluations of the conditional likelihood, and (iv) are suitable for training of deep models. Here, EM, SA, S, T, MC and MH stand for expectation-maximization, stochastic approximation, sparse, truncated, Monte Carlo and Metropolis-Hastings, respectively.   
+
+<table><tr><td>Feature/Algorithm</td><td>EM [13]</td><td>SAEM [44]</td><td>SSAEM [24]</td><td>TSAEM [18]</td><td>MCSAEM [1]</td><td>MHSAEM (ours)</td></tr><tr><td>B&lt;Ndatapoints</td><td>×</td><td></td><td></td><td>√</td><td></td><td></td></tr><tr><td>M&lt;K statistics</td><td>xx</td><td></td><td></td><td></td><td>厂</td><td></td></tr><tr><td>M&lt;Klikelihoods</td><td></td><td>xx</td><td>×</td><td></td><td>X</td><td></td></tr><tr><td>deep models</td><td>×</td><td>×</td><td>×</td><td>X</td><td>×</td><td></td></tr></table>
+
+44 In this paper, we make the following contributions:
+
+45 • We propose an EM-based algorithm which relies on the MH sampler to stochastically evaluate less   
+46 components in mixture models, substantially reducing the computational cost.   
+7 • We design our method to enable optimization of fairly generic EM objective functions, making it   
+48 suitable for training of both shallow and deep mixture models.   
+49 • We apply our approach to Gaussian mixture mdoels (GMMs) and their generalizations: sum  
+50 product-transform networks (SPTNs) and mixtures of real-valued non-volume preserving (real   
+51 NVP) flows [15], reaching approximately $1 0 0 \times$ speed-up compared to state-of-the-art methods.
+
+# 52 2 Problem formulation
+
+A finite mixture model characterizes the relation between an observed (known) variable, 53 $\boldsymbol { x } \in \times \subseteq \mathbb { R } ^ { D }$ , 54 and a latent (unknown) variable, $z \in Z : = \{ 1 , \dots , K \}$ , via the marginal (incomplete-data) likelihood 55 in the following form:
+
+$$
+p _ { \theta } ( x ) = \sum _ { k = 1 } ^ { K } p _ { \eta _ { k } } ( x | z = k ) p _ { \pi _ { k } } ( z = k ) ,
+$$
+
+56 where $\theta : = ( \pi _ { 1 } , \eta _ { 1 } , \dots , \pi _ { K } , \eta _ { K } ) \in \Theta$ are unknown parameters. Here, $\eta _ { z }$ are the parameters of the 57 conditional likelihood, $p _ { \eta _ { z } } ( x | z )$ , and $\pi _ { z }$ is the weight which parameterizes the prior, $p _ { \pi _ { z } } ( z ) = \pi _ { z }$ , and satisfies 58 $0 \leq \pi _ { k } \leq 1$ for each $k \in { \mathord { \mathbb { Z } } }$ and $\textstyle \sum _ { k = 1 } ^ { K } \pi _ { k } = 1$ .
+
+59 Given a set of independent and identically distributed data, $\mathbf { x } : = ( x _ { i } ) _ { i = 1 } ^ { N }$ , our goal is to learn the   
+60 unknown parameters of the marginal log-likelihood,
+
+$$
+\mathcal { L } ( \theta ) : = \log p _ { \theta } ( \mathbf { x } ) = \sum _ { i = 1 } ^ { N } \log \sum _ { k = 1 } ^ { K } p _ { \eta _ { k } } ( x _ { i } | z _ { i } = k ) p _ { \pi _ { k } } ( z _ { i } = k ) .
+$$
+
+61 The marginalization in (2) is tractable for almost all forms of $p _ { \eta _ { z } } ( x | z )$ . Indeed, we consider $p _ { \eta _ { z } } ( x | z )$   
+62 to belong to an arbitrary family of $\eta _ { z }$ -differentiable probability distributions. However, we assume that   
+63 $K$ is high, making the marginalization in (2) computationally costly, thus rendering the optimization   
+64 objective presumably intractable. Therefore, we want to design a computationally efficient algorithm,   
+65 requiring only $M < K$ evaluations of $p _ { \eta _ { z } } ( x | z )$ at each iteration.   
+67 The maximum likelihood estimation seeks the parameters maximizing the marginal log-likelihood,   
+68 $\theta ^ { M L } : = \arg \operatorname* { m a x } _ { \theta \in \Theta } \mathcal { L } ( \theta )$ . The traditional EM algorithm [13] addresses this task indirectly, i.e. by   
+69 optimizing the evidence lower bound (ELBO),
+
+$$
+\mathcal { L } ( \theta ) \geq \mathcal { Q } ( \theta ) + \mathcal { H } ( \hat { \theta } ) : = \mathrm { E L B O } ( \hat { \theta } ) ,
+$$
+
+where 70 $\mathcal { H } ( \hat { \theta } ) : = - \mathsf E _ { p _ { \hat { \theta } } ( \mathbf { z } | \mathbf { x } ) } [ \log p _ { \hat { \theta } } ( \mathbf { z } | \mathbf { x } ) ]$ is the differential entropy at an estimate, $\hat { \theta } \in \Theta$ , and
+
+$$
+\mathcal { Q } ( \theta ) : = \mathsf { E } _ { p _ { \hat { \theta } } ( \mathbf { z } | \mathbf { x } ) } [ \log p _ { \theta } ( \mathbf { z } , \mathbf { x } ) ] = \sum _ { i = 1 } ^ { N } \sum _ { k = 1 } ^ { K } p _ { \theta } ( z _ { i } = k | x _ { i } ) \log p _ { \theta } ( z _ { i } = k , x _ { i } )
+$$
+
+71 is the EM objective function. Here, $p _ { \theta } ( \mathbf { z } , \mathbf { x } )$ is the joint (complete-data) likelihood, and $p _ { \theta } ( \mathbf { z } | \mathbf { x } )$ is   
+72 the posterior distribution over the latent variables $\dot { \mathbf { z } } : = ( z _ { i } ) _ { i = 1 } ^ { N }$ . Given an initial value, $\theta _ { 0 }$ , the EM   
+73 algorithm produces a sequence of estimates, $( \theta _ { t } ) _ { t = 1 } ^ { T }$ , by alternating between the expectation (E) and   
+74 maximization (M) steps,
+
+$$
+\begin{array} { r l } & { \mathrm { E \mathrm { - } s t e p } ; ~ \mathcal { Q } _ { t - 1 } ( \theta ) , } \\ & { \mathrm { M \mathrm { - } s t e p } ; ~ \theta _ { t } : = \arg \operatorname* { m a x } _ { \theta \in \Theta } \mathcal { Q } _ { t - 1 } ( \theta ) . } \end{array}
+$$
+
+75 This sequence is guaranteed to monotonically tighten the ELBO, arriving at a local optimum of (2)   
+76 under mild regularity assumptions [56].   
+77 The EM algorithm is computationally expensive, since (4) evaluates $p _ { \theta } ( z _ { i } , x _ { i } )$ for each $z _ { i } \in \mathbb { Z }$ and   
+78 $i \in ( 1 , \ldots , N )$ . This has to be performed for all $t \in ( 1 , \ldots , T )$ in (5). Albeit the marginal factor,   
+79 $p _ { \pi _ { z } } ( z )$ , is just the cheap categorical distribution, the conditional factor, $p _ { \eta _ { z } } ( x | z )$ , typically involves   
+80 high-dimensional operations (e.g., the inversion of the full $D \times D$ -dimensional covariance matrices   
+81 in the GMMs). Moreover, the M-step (6) is also expensive for large $K$ . This holds despite that (6)   
+82 can be reduced to closed-form updates of expected sufficient statistics for $p _ { \eta _ { z } } ( x | z )$ belonging to the   
+83 exponential family [44] (again, due to high $D$ ). All in all, the computational complexity of the EM   
+84 algorithm scales with $\mathcal { O } ( T D N K )$ .
+
+If (6) cannot be computed under a closed-form solution, one can resort to direct gradient-descent optimization of $\mathcal { Q } ( \boldsymbol { \theta } )$ , where arg max is replaced by one (or more) step(s) of a gradient descent technique. The EM algorithm is then referred to as the generalized EM algorithm [56].
+
+# 88 4 The generalized MHSAEM algorithm
+
+89 We design a version of the generalized EM algorithm suitable for scenarios where (4) can represent   
+90 deep, discrete, latent variable models, thus being parameterized by possibly complex nonlinear   
+91 transformations. We particularly focus on decreasing the the number of operations in the generalized   
+92 EM algorithm from $\mathcal { O } ( T D N K )$ to $\mathcal { O } ( T D B M )$ , where $B \ll N$ and $M \ll K$ .
+
+# 4.1 E-step
+
+94 We reduce the cost of evaluating the EM objective function (4) by combining the minibatching (as   
+95 used many times before) and the Monte Carlo sampling. Namely, the specific application of the latter   
+96 to generic mixture models is the key contribution of this paper.   
+97 Minibatching. At each iteration, $t$ , we compute the conditional expectation in (4) only for a subset—   
+98 here referred to as a minibatch—of the original full dataset, i.e. $( x _ { i } ) _ { i \in I }$ . Here, $I$ is a set of $B \ll N$   
+99 indices, $i$ , sampled uniformly without replacement from $( 1 , \ldots , \dot { N } )$ . This substantially decreases the   
+100 necessary computations compared to the full sweep over all $N$ datapoints [23].   
+101 Monte Carlo sampling. For each $i \in I$ , we want to draw $M \ll K$ random samples from $p _ { \theta } ( z _ { i } | x _ { i } )$ in   
+102 order to obtain a Monte Carlo estimate of (4). The straightforward way to do this would be to draw   
+103 the samples directly from $p _ { \theta } ( z _ { i } | x _ { i } )$ . However, direct sampling from $p _ { \theta } ( z _ { i } | x _ { i } )$ does not lead to any   
+104 substantial decrease in the number of operations. This is caused by the fact that even for a single   
+105 sample of $z _ { i }$ , we have to first compute the normalizing factor, $p _ { \theta } ( x _ { i } )$ , to obtaining the posterior,   
+106 $p _ { \theta } ( z _ { i } | x _ { i } )$ . This requires $K$ expensive evaluations of $p _ { \theta } ( z _ { i } , x _ { i } )$ , which is precisely what we want to   
+107 avoid. Our approach is to resort to the Markov chain Monte Carlo (MCMC), which allows us to   
+108 sample from $p _ { \theta } ( z _ { i } | x _ { i } )$ , with the computational complexity decreasing to only a single evaluation of   
+109 $p _ { \theta } ( z _ { i } , x _ { i } )$ per a single sample of $z _ { i }$ .   
+110 MCMC methods obviate the computation of the normalizing factor in $p _ { \theta } ( z _ { i } | x _ { i } )$ by simulating a   
+111 Markov chain, $( z _ { i , t } ) _ { t = 1 } ^ { T }$ , from a transition kernel, $z _ { i , t } \sim P ( z _ { i , t - 1 } , \cdot )$ , which leaves $p _ { \theta } ( z _ { i } | x _ { i } )$ as its   
+112 unique stationary (invariant) distribution, starting from an initial value $z _ { i , 0 }$ . The specific form of $P$   
+113 determines the structure of an MCMC method. We chose the Metropolis-Hastings (MH) sampler,   
+114 which represents $P ( z _ { i , t - 1 } , z _ { i , t } )$ as follows: given $\bar { z } _ { i } : = z _ { i , t - 1 }$ , draw a sample from the proposal   
+115 distribution $z _ { i } \sim q ( \cdot | \bar { z } _ { i } )$ , compute the acceptance ratio,
+
+$$
+\alpha ( \bar { z } _ { i } , z _ { i } ) : = \operatorname* { m i n } \biggr \{ 1 , \frac { p _ { \eta _ { z _ { i } , t - 1 } } ( x _ { i } | z _ { i } ) \pi _ { z _ { i } , t - 1 } q ( \bar { z } _ { i } | z _ { i } ) } { p _ { \eta _ { \bar { z } _ { i } , t - 1 } } ( x _ { i } | \bar { z } _ { i } ) \pi _ { \bar { z } _ { i } , t - 1 } q ( z _ { i } | \bar { z } _ { i } ) } \biggr \} ,
+$$
+
+116 and, if $u < \alpha \big ( \bar { z } _ { i } , z _ { i } \big )$ —where $u$ is drawn from a uniform distribution, Uniform $( 0 , 1 )$ —accept the   
+117 sample and set $z _ { i , t } = z _ { i }$ ; otherwise, set $z _ { i , t } = \bar { z } _ { i }$ . For each $i \in I$ and $t \in ( 1 , \ldots , T )$ , we repeat   
+118 this process $M$ times, construing a set $\mathbf { z } _ { i , t } = ( z _ { i , t } ^ { 1 } , \dots , z _ { i , t } ^ { M } )$ . Therefore, at every current iteration,   
+119 120 $t$ , we caking $\bar { z } _ { i } = z _ { i , t - 1 } ^ { M }$ extend the chain from the point where we left at the previous iteration, . Under mild regularity assumptions [52], the chain passes the transiti $t - 1$ , byriod   
+121 (the burn-in phase), and the samples can then be used to approximate the conditional expectation in   
+122 (4) as follows:
+
+$$
+\widehat { \mathcal { Q } } _ { t - 1 } ( \theta ) = \frac { 1 } { M } \sum _ { i \in I } \sum _ { z \in \mathbf { z } _ { i , t } } \log p _ { \eta _ { z } } ( x _ { i } | z ) \pi _ { z } .
+$$
+
+123 Note that, to ensure this approach is truly efficient, we have to draw only $M \ll K$ samples at each   
+124 iteration, $t$ ; otherwise, for $M \approx K$ , we may rather compute the exact marginalization in (4), since it   
+125 is tractable (but computationally costly).
+
+# 4.2 M-step
+
+127 Assume for a moment that (6) with $\mathcal { Q } _ { t - 1 } ( \theta )$ given by (8) has a closed-form solution, yielding an   
+128 estimate of $\theta$ . Such an estimate would have a high variance, converging only for $M \to \infty$ and   
+129 $T \to \infty$ [19]. The main reason is that the samples would not be reused over the iterations, $t$ ,   
+130 thus wasting computational resources. We consider that there is no closed-form solution of (6),   
+131 and—to ensure that the samples (and thus computations) are recycled over the iterations—we use   
+132 the stochastic approximation (SA) [51] to optimize (8). This is analogous to applying a stochastic   
+133 gradient-descent method, $\theta _ { t } = \theta _ { t - 1 } + \gamma _ { t } \nabla _ { \theta } \tilde { \mathcal { Q } } _ { t - 1 } ( \theta )$ , where $\gamma _ { t }$ is the step-size, satisfying the Robbins  
+134 Monro constraints, $\begin{array} { r } { \gamma _ { t } \in [ 0 , 1 ] , \sum _ { t \geq 1 } \gamma _ { t } = \infty , \sum _ { t \geq 1 } \gamma _ { t } ^ { 2 } < \infty , } \end{array}$ and $\nabla _ { \theta }$ is the gradient w.r.t. $\theta$ . In this   
+135 way, the computations made in $\nabla _ { \boldsymbol { \theta } } \widehat { \mathcal { Q } }$ are accumulated via $\theta _ { t }$ and reused over the iterations.   
+136 The parameters $\eta _ { z }$ have a different form based on a specific case of $p _ { \eta _ { z } } ( x | z )$ , whereas $\pi _ { z }$ is a   
+137 permanent structure in (1). Therefore, without loss of generality, we split (6) into a generic part and a   
+138 fixed part as follows:
+
+$$
+\begin{array} { r l } & { \eta _ { k , t } = \eta _ { k , t - 1 } + \gamma _ { t } \nabla _ { \eta _ { k } } \widehat { \mathcal { Q } } _ { t - 1 } ( \theta ) , } \\ & { \nu _ { k , t } = \nu _ { k , t - 1 } + \gamma _ { t } \nabla _ { \nu _ { k } } \widehat { \mathcal { Q } } _ { t - 1 } ( \theta ) , } \end{array}
+$$
+
+139 where—to ensure that the probabilities, $( \pi _ { k , t } ) _ { k = 1 } ^ { K }$ , satisfy the constraints (Section 2)—we transform   
+140 $\nabla _ { \pi _ { k } } \widehat { \mathcal { Q } }$ via $\nu _ { k } = \log \pi _ { k }$ and optimize w.r.t. $\nu _ { k }$ . Then, to obtain $( \pi _ { k , t } ) _ { k = 1 } ^ { K }$ from $\nu _ { t } : = ( \nu _ { k , t } ) _ { k = 1 } ^ { K }$ , we   
+141 k b  use the softmax function, i.e. $\pi _ { k , t } : = \mathrm { s o f t m a x } ( \pmb { \nu } _ { t } ) _ { k } : = \exp ( \nu _ { k , t } ) / \sum _ { l = 1 } ^ { K } \exp ( \nu _ { l , t } )$ .
+
+Computing the gradients for all pairs of $( \nu _ { k } , \eta _ { k } ) _ { k = 1 } ^ { K }$ would be inefficient, especially since ${ \bf z } _ { i , t }$ contains only a small number of unique values of Z for $M \ll K$ . Consequently, we compute $\dot { \nabla } _ { \eta _ { k } } \widehat { \mathcal { Q } }$ and $\nabla _ { \nu _ { k } } \widehat { \mathcal { Q } }$ only for $k \in { \mathrm { u n i q u e } } ( \mathbf { z } _ { i , t } )$ . We summarize the proposed approach in Algorithm 1.
+
+# 4.3 Proposal distribution
+
+146 The choice of the proposal distribution has a significant impact on the speed of convergence and the computational cost of the proposed algorithm. Here, we discuss various possible choices of 147 $q \big ( z _ { i } | \bar { z } _ { i } \big )$ .
+
+Input: $\theta _ { 0 }$ , $( \mathbf { z } _ { i , 0 } ) _ { i = 1 } ^ { N }$ , $( \mathbf { x } _ { i } ) _ { i = 1 } ^ { N }$   
+Output: $( \theta _ { t } ) _ { t = 1 } ^ { T }$ for $t \in ( 1 , \ldots , T )$ or until convergence do form the set $\dot { I } = ( i _ { j } ) _ { j = 1 } ^ { B }$ by sampling (without replacement) $B$ indices $i \sim ( 1 , \dots , N )$ for $i \in I$ do set $\bar { z } _ { i }$ as the last element of $\mathbf { z } _ { i , t - 1 }$ for $j \in ( 1 , \ldots , M )$ do sample $z _ { i } \sim q ( z _ { i } | \bar { z } _ { i } )$ sample $u \sim \mathrm { U n i f o r m } ( 0 , 1 )$ compute $\alpha ( \bar { z } _ { i } , z _ { i } )$ in (7) if $u < \alpha \big ( \bar { z } _ { i } , z _ { i } \big )$ then set $z _ { i , t } ^ { j } = z _ { i }$ and $\bar { z } _ { i } = z _ { i }$ else set $z _ { i , t } ^ { j } = \bar { z } _ { i }$ end if end for set $\mathbf { z } _ { i , t } = ( z _ { i , t } ^ { 1 } , \dots , z _ { i , t } ^ { M } )$ end for compute (8) compute (9) for $k \in { \mathrm { u n i q u e } } ( \mathbf { z } _ { i , t } )$ compute $\pi _ { k , t } : = \mathrm { s o f t m a x } ( \pmb { \nu } _ { t } ) _ { k }$ for $k \in { \mathord { \mathbb { Z } } }$ end for
+
+148 Optimal proposal $( O )$ . The optimal proposal distribution is $q ( z _ { i } | \bar { z } _ { i } ) : = q ( z _ { i } ) : = p _ { \theta } ( z _ { i } | x _ { i } )$ . This   
+149 ensures that the acceptance rate (7) is always $\alpha ( \bar { z } _ { i } , z _ { i } ) = 1$ . However, the need to perform $K$   
+150 expensive evaluations of $p _ { \theta } ( z _ { i } , x _ { i } )$ before sampling from $p _ { \theta } ( z _ { i } | x _ { i } )$ is the reason we resorted to   
+151 the MH sampler in the first place. We consider this case only to set the upper limit on admissible   
+152 computational cost and to study the impact of sub-optimal proposal distribtions.   
+153 Uniform proposal $( U )$ . The uniform distribution on the discrete interval from 1 to $K$ , i.e. $q ( z _ { i } | \bar { z } _ { i } ) : =$   
+154 $q ( z _ { i } ) : = \mathrm { U n i f o r m } ( 1 , K )$ , is the simplest and computationally cheapest variant of the proposal   
+155 distribution. However, due to poor mixing properties, the algorithm may converge slowly for high $K$ .   
+156 Tabular proposal with forgetting $( T F )$ . The key requirement to design a proposal distribution is to   
+157 restrict its computational complexity somewhere between that of the $\mathrm { U }$ and $\mathrm { o }$ proposals. One way to   
+158 satisfy this constraint is to use the Markov chain, $( z _ { i , t } ) _ { t = 1 } ^ { T }$ , to learn a transition kernel, $p ( z _ { i } | \bar { z } _ { i } )$ , see,   
+159 e.g. [3]. Unfortunately, this would require us to store a table with $K ^ { 2 }$ entries for each $i \in ( 1 , \ldots , N )$ ,   
+160 161 which is very demanding evethe Markov chain and define: $q ( z _ { i } | \bar { z } _ { i } ) : = q _ { \alpha _ { i } } ( z _ { i } ) : = \mathcal { C } ( \alpha _ { i } )$ $K$ $N$ herefore, where $\mathcal { C } ( \pmb { \alpha } _ { i } ) \propto \Pi _ { k = 1 } ^ { K } \alpha _ { k , i } ^ { \bar { 1 ( } z _ { i } = k ) }$ nce inis the   
+162 categorical distribution with the weights $\pmb { \alpha } _ { i } : = ( \alpha _ { 1 , i } , \dots , \alpha _ { K , i } )$ . For $\mathcal { L } ( \pmb { \alpha } _ { i } ) : = \Sigma _ { \tau = 1 } ^ { t } \log q _ { \pmb { \alpha } _ { i } } ( z _ { i , \tau } )$   
+163 we obtain an estimate of $\alpha _ { i }$ at iteration $t$ as follows: $\begin{array} { r } { \alpha _ { i , t } : = \mathrm { \ a r g m a x } _ { \alpha _ { i } } \mathcal L ( \alpha _ { i } ) \ = \ \frac { n _ { i , t } } { t } } \end{array}$ t , with   
+164 $n _ { i , t } = \Sigma _ { \tau = 1 } ^ { t } \mathbf { e } _ { z _ { i , t } }$ , where $\mathbf { e } _ { k }$ is the standard basis vector (a one-hot vector) with one at $k$ th position   
+165 and zeros otherwise. This can be further rewritten into a recursive form: $n _ { i , t } = n _ { i , t - 1 } + \mathbf { e } _ { z _ { i , t } }$ or,   
+166 using the Robbins-Monro step-size, $n _ { i , t } = ( { \bf 1 } - { \bf e } _ { z _ { i , t } } \gamma _ { t } ) \odot n _ { i , t - 1 } + \gamma _ { t } { \bf e } _ { z _ { i , t } }$ , where 1 is the vector of   
+167 ones, and $\odot$ is the Hadamard product. We refer to this case simply as “table with forgetting” (TF)   
+168 due to that it represents $N \times K$ table in the memory and $\gamma _ { t }$ is a forgetting factor.
+
+# 169 5 Related work
+
+Stochastic approximation expectation-maximization. The application of SA to prevent the evaluation   
+1 of all $K$ components in mixture models has been overlooked for a long time. The reason is that the   
+72 original motivation to combine the EM algorithm with SA is to address the analytical intractability   
+73 of the expected value under $p _ { \theta } ( z | x )$ in (4), which is, however, almost always tractable for mixture   
+74 models. The intractability issue is addressed by either the Monte Carlo SAEM (MCSAEM) [12]   
+75 or the Markov chain Monte Carlo SAEM (MCMCSAEM) [31]. Applying the former approach to   
+76 mixture models would be inefficient, since it evaluates $K$ joint distributions, $p _ { \theta } ( z , x )$ , before drawing   
+177 $M$ samples from $p _ { \theta } ( z | x )$ . Therefore, this method reduces only the computational cost of updating the   
+178 sufficient statistics. This is addressed by the latter approach, where $M < K$ samples from a proposal   
+179 distribution, $q ( z | x )$ , is used to calculate $p _ { \theta } ( z , x )$ and also the sufficient statistics. However, all these   
+180 methods process all data at every iteration, providing only a limited advantage over the conventional   
+181 EM algorithm. Minibatch versions of these techniques have recently been proposed [27, 32, 1].   
+182 All the above methods commonly assume $p _ { \theta } ( z , x )$ belonging to the exponential family. This provides   
+183 a convenient, but limiting, property which allows (6) to be computed under a closed-form solution.   
+184 The main contribution of our work is to release this restrictive assumption by admitting that $p _ { \theta } ( z , x )$   
+185 (and thus $\mathcal { Q }$ ) is given by possibly complex and intractable transformations.   
+186 Sparse and truncated variational techniques. There is only a small body of methods explicitly   
+187 reducing the number of evaluated components. Their common aspect is that they follow from the   
+188 variational framework, where the exact posterior, $p _ { \theta } ( z | x )$ , is approximated by a variational posterior,   
+189 $q ( z | x )$ . This sparse, approximate, posterior is defined over a lower number of components, $M \ll K$ ,   
+190 such that only the important components are selected, relying on relaxation of the hard EM algorithm   
+191 from taking a single $M = 1$ assignment [26] to taking multiple $M \ll K$ assignments. The sparse   
+192 SAEM (SSAEM) algorithm [24] selects the components by a quick partial sorting of the posterior   
+193 probabilities, $p _ { \theta } ( z | x )$ . Again, this requires $K$ evaluations of $p _ { \theta } ( z , x )$ before the sorting, thus only   
+194 reducing the amount of updated statistics. Similarly, the truncated SAEM (TSAEM) algorithm [18]   
+195 selects $M < K$ cluster-to-cluster and $\bar { M } < K$ cluster-to-datapoint minimal Euclidean distances,   
+196 preventing the problem in the SSAEM algorithm. However, all these distances are evaluated for all   
+197 components in a pairwise manner, leading to $K ^ { 2 }$ -computational complexity, which makes the saving   
+198 dubious. Similarly as before, these methods assume $p _ { \theta } ( z , x )$ to belong to the exponential family.
+
+![](images/0c516376ee7ecf27c7edaec6674fb19224d829bc10798ac37d421adee064aa0e.jpg)  
+Figure 1: The training log-likelihood, $\mathcal { L } ( \boldsymbol { \theta } _ { t } )$ , versus the computational time (in seconds). Here, on the $\mathbf { X }$ -axis, the computational time at a current iteration, $t$ , is obtained by accumulating the time from the previous iterations. corresponds to $\mathcal { L } ( \boldsymbol { \theta } _ { t _ { 9 5 } } )$ , where $t _ { 9 5 }$ is the iteration of reaching $9 5 \%$ of max $\mathcal { L } ( \boldsymbol { \theta } _ { t } )$ . The projection of $^ { \circ }$ on the $\mathbf { X }$ -axis gives the time to reach $\mathcal { L } ( \boldsymbol { \theta } _ { t _ { 9 5 } } )$ . This experiment was performed with the following settings: $( D , \bar { K } , N , \omega , B , M , T ) = ( 1 0 , 1 0 0 , 1 0 k , 0 . 1 , \bar { 2 } 0 0 , 2 , 2 0 k )$ , see Section 6.1 for details. The results are averaged over five repetitions.
+
+199 We summarize the distinguishing features of the above discussed methods in Table 1.
+
+# 6 Experiments
+
+To demonstrate the key features of our algorithm—its low computational complexity, competitive learning performance, and generality—we use it below to train: (i) GMMs on synthetic datasets, and (ii) SPTNs [47] and (iii) mixtures of real NVP flows [48] on real datasets. All experiments have been performed on a Slurm cluster equipped with Intel Xeon Scalable Gold 6146 with 384GB of RAM.
+
+# 6.1 Gaussian mixture models
+
+Consider the special case of a data-generating distribution given by (1), with the components taking the form of the multivariate Gaussian distribution, $p _ { \eta _ { z } } ( x | z ) = \mathcal { N } ( x ; \mu _ { z } , \Sigma _ { z } )$ , where $\mu _ { z }$ is the mean value and $\Sigma _ { z }$ is the covariance matrix. The difficulty of learning GMMs heavily depends on the degree of interaction among all mixture components, hence having the ability to generate synthetic datasets with arbitrary overlap characteristics between all pairs of components is crucial for systematic
+
+![](images/0ced572977ae404a4e785379dc4987ce758b6f6930ca4d73adbe35955ed678b7.jpg)  
+Figure 2: The absolute error, $\mathrm { A E } = | \mathcal { L } ( \theta _ { t _ { 9 5 } } ) - \mathcal { L } ( \theta ) |$ , versus the computational time (in seconds). All experiments use the following settings: $( D , K , \dot { N } , \omega , B , M , T ) = \bar { ( } 1 0 , 1 0 0 , 1 0 k , 0 . 1 , 2 0 0 , 2 , 2 0 k )$ , where the number of components, $K$ , (left), the batchsize, $B$ , (middle) and the number of samples, $M$ , (right) change for different values denoted by $( + , \sqsupset , \circ , \pmb { \triangle } )$ . At each of these points (marks), we perform an experiment as illustrated in Figure 1, find $\mathcal { L } ( \boldsymbol { \theta } _ { t _ { 9 5 } } )$ to compute the AE, and record the time corresponding to $t _ { 9 5 }$ . The results are averaged over five repetitions.
+
+211 evaluation of performance of learning algorithms [43]. Traditional techniques usually define overlap   
+212 (or separation) of components only in terms of their mean vectors and maximum eigenvalues of the   
+213 covariance matrices, not accounting for their rotation and mixing weights (see [36] for a detailed   
+214 treatment of the problem). We therefore use a more objective measure of the clustering complexity   
+215 defined by the total probability of misclassification [41], which allows to generate data with a   
+216 user-defined degree of maximum pairwise overlap, $\omega$ .   
+217 Experiment settings: We generate the parameters of (1), and the corresponding dataset, uniquely for a   
+218 given quadruple $( D , K , N , \omega )$ . Therefore, the parameters of the generative model are known and we   
+219 can measure and display the convergence of the training log-likelihood, $\mathcal { L } ( \boldsymbol { \theta } _ { t } )$ , compared to the exact   
+220 log-likelihood, $\mathcal { L } ( \boldsymbol { \theta } ) \dot { }$ , for $t = ( 1 , \ldots , T )$ . We are further interested in the absolute error between the   
+221 training log-likelihood at the iteration of reaching $9 5 \%$ of its maximum value, $t _ { 9 5 }$ , and the exact   
+222 log-likelihood, i.e. $\mathrm { A E } = | \mathcal { L } ( \theta _ { t _ { 9 5 } } ) - \mathcal { L } ( \theta ) |$ .   
+23 We also measure the computational time until reaching $t _ { 9 5 }$ . We have used $9 5 \%$ of the maximum   
+24 value instead of the maximum value to prevent cases, where the model oscillate around target value,   
+25 making the estimate of convergence time very noisy (for example MCSAEM in Figure 1).   
+226 Algorithms: The GMMs belong to the exponential family of probability distributions. This allows us   
+227 to find a closed-form, recursive, solution of (6), relying on a Robbins-Monro type of the step-size   
+228 sequence, $( \gamma _ { t } ) _ { t = 1 } ^ { T }$ , [7, 44]. In this setting, we compare our MHSAEM algorithm with a number of   
+229 related methods in Table 1. Note we use the acronyms U and TF to specify the proposal distribution of   
+230 the MHSAEM algorithm (Section 4.3). However, we do not use the O-proposal, since the MHSAEM  
+231 O algorithm is equivalent to the MCSAEM algorithm. All the SA-variants in Table 1 use a minibatch   
+232 of size $B$ . The key quantity to reduce the number of evaluated components and/or sufficient statistics   
+233 in the SSAEM, TSAEM, MCSAEM and MHSAEM algorithms is collectively denoted by $M$ (Section   
+234 5). Note that we always keep $M = \bar { M }$ in the TSAEM algorithm (see Figure 1 and 2 for concrete   
+235 numbers). We use the step-size given by $\gamma _ { t } = 1$ for $t = 1 , \ldots , 5 0$ and $\gamma _ { t } = 0 . 0 5$ otherwise. In   
+236 this section, to counteract the issue of attaining poor local optima, we equip all algorithms with the   
+237 anti-annealing schedule $( \beta _ { t } ) _ { t = 1 } ^ { T }$ , starting with $\beta _ { 1 } = 0 . 1$ , reaching $\beta _ { 2 / 3 T } = 1 . 2$ , and decreasing back   
+238 to $\beta _ { T } = 1 . 0$ , see [43] for details. The initial estimates of: (i) $\mu _ { k }$ are uniformly drawn from the unit   
+239 hyper-cube, (ii) $\Sigma _ { k }$ are fixed to unit diagonal matrix, and (iii) $\pi _ { k }$ are uniformly drawn from the unit   
+240 interval (followed by normalization).   
+241 Results: Figure 1 shows that the EM [13] and SAEM [44] algorithms take the longest time to   
+242 converge, attaining a poor local optima. On the other hand, the MCSAEM [1] and MHSAEM (U   
+243 and TF) algorithms achieve $\mathcal { L } ( \boldsymbol { \theta } _ { t _ { 9 5 } } )$ closest to the likelihood $\mathcal { L } ( \boldsymbol { \theta } )$ of the true model. Moreover, both   
+244 MHSAEM algorithms reach this value in the shortest time compared to all the other methods. The   
+245 SSAEM [24] and TSAEM [18] algorithms are comparable in terms of the computational time, but   
+246 they both provide the lowest $\mathcal { L } ( \boldsymbol { \theta } _ { t _ { 9 5 } } )$ . In Figure 2, we investigate sensitivity of fitting the model to   
+47 increasing values of $K$ , $B$ and $M$ by measuring the time and the likelihood again. In all the cases,   
+48 the proposed MHSAEM algorithms achieve the lowest AE in the shortest time.
+
+SSAEM and TSAEM algorithms failed to converge for $M > 2$ and for $K > 5 0$ respectively. We believe this is caused by selecting only $M$ maximal probabilities in the SSAEM (or distances in the TSAEM) algorithm (Section 5), which prevents certain, but not a negligible number of, components from being updated, thus providing only a crude approximation of $\bar { p } _ { \theta } \bar { ( } z | x )$ . The results then suffer from substantial variational gap to the exact log-likelihood (Figure 1). On the contrary, MH sampler provides samples which consistently approximate $p _ { \theta } ( z | x )$ despite evaluating much lower number of components in each step.
+
+# 6.2 Sum-product transform networks
+
+The sum product networks (SPNs) are a deep learning extension of finite mixture models. They can be interpreted as a mixture of trees [60], where each tree corresponds to a component. Therefore, they can be cast into the form of (1), but the number of components grows exponentially with their depth. In this section, we use recently proposed SPTNs which introduce additional transformation nodes to provide better expressiveness than the SPNs (SPTNs effectively generalize SPNs and flow models into one large family of models).
+
+Experimental settings: We use 19 real datasets from the UCI database [16, 37, 35, 54], preprocessed in the same way as in [46]. For each experiment, we randomly split the data into $64 \%$ , $16 \%$ and $20 \%$ for training, validation and testing, respectively. We calculate the average log-likelihood on the test set and measure again the time to reach $9 5 \%$ of the maximal training log-likelihood, $\mathcal { L } ( \boldsymbol { \theta } _ { t _ { 9 5 } } )$ .
+
+To evaluate various (possibly shallow and/or deep) architectures of SPTNs, we fit each dataset with all the following combinations of hyper-parameters1: $s \in ( 8 , 3 2 , 1 2 8 )$ , $b \in ( 2 , 4 , 6 , 8 )$ , $l \in ( 2 , 3 , 4 )$ , where $s$ is the number of children of each sum node, $b$ is the number of partitions of each product node, and $l$ is the number of layers (one layer contains sum and product nodes). The number of components of the SPTN, after its conversion into (1), is given as follows: $K = s ^ { l }$ . Note that the maximum number of components for the investigated parameters of the SPTN is 268,435,456. To reduce the space of possible architectures, we restrict ourselves only to (i) the leaf nodes given by $\mathcal { N } ( 0 , \bf { I } )$ ; (ii) affine transformations fixed to the singular value decomposition, choosing the the Givens parameterization for the unitary matrices [47]; and (iii) no sharing of any type of nodes [47].
+
+276 Algorithms: We evaluate only on the MHSAEM-U algorithm—due to its favourable computational   
+277 complexity and simplicity—and compare it with the stochastic gradient-descent (SGD) algorithm,   
+278 which is routinely used to train SP(T)Ns [45, 47]. In this case, SGD in each iteration performs   
+279 computations over all subtrees of the network, whereas the MHSAEM-U algorithm computes with   
+280 only $M = 1$ subtrees, thus we should observe speed-up of the computations. In our implementation,   
+281 both these methods perform optimization of their respective objective functions—the log-likelihood   
+282 (2) for SGD and the EM objective (8) for MHSAEM-U—via the use of the automatic differentiation   
+283 and the ADAM optimizer [29], using $B = 1 0 0$ and $T = 2 0 0 0 0$ .
+
+Results: Since each dataset might benefit from a different architecture, Table 6.2 shows the test log-likelihood of the architectures selected according to the best likelihood measured on the validation set and the corresponding speed-up. The test log-likelihoods reveal that the MHSAEM-U algorithm outperforms the SGD algorithm on 10 out of 19 datasets, which was not originally the goal, but the added stochasticity helps to escape poor local minima. The speed-up demonstrates lower computational complexity of the MHSAEM-U algorithm on 17 out of 19 datasets, which was the main goal. The magic-telescope and wine datasets show approximately $1 0 2 \times$ and $7 5 \times$ speed-up, respectively, while on very small datasets (pima-indians and iris), the SGD is faster due to effective implementation. In the supplementary material, we present Table 3, exhibiting the same trends on a fixed architecture.
+
+# 6.3 Mixtures of real NVP flows
+
+We consider another class of mixture models (1), where each component $p _ { \eta _ { z } } ( x | z )$ is transformed by the flow model—real NVP [15]. These transformations are parameterized via deep neural networks, allowing for flexible adjustment of the learning capacity of each component.
+
+Table 2: The speed-up and test log-likelihood, $\mathcal { L } ^ { \mathrm { t e s t } }$ , for the SGD and MHSAEM-U algorithms. The test log-likelihood (higher is better) is computed for the best model, with the corresponding $K$ , which is selected based on the validation log-likelihood. The speed-up is computed as the ratio of MHSAEM-U to SGD, i.e. their time to reach $9 5 \%$ of the training log-likelihood. The results are averaged over five repetitions. Then, the higher test log-likelihood is highlighted with bold blue, and and no speed-up is highlighted with red. The average rank is computed as the standard competition (“1224”) ranking [14] on each dataset (lower is better).   
+
+<table><tr><td rowspan="3"></td><td colspan="5">Sum-product transformnetworks</td><td colspan="5">Mixtures of real NVP flows SGD</td></tr><tr><td rowspan="2"></td><td colspan="2">SGD</td><td colspan="2">MHSAEM-U</td><td colspan="2"></td><td colspan="2"></td><td colspan="2">MHSAEM-U</td></tr><tr><td>speed-up</td><td>Ltest</td><td>K</td><td>Ltest</td><td>K</td><td>speed-up</td><td>Ltest</td><td>K 32</td><td>Ltest</td><td>K</td></tr><tr><td>breast-cancer-wisconsin</td><td>4.66</td><td>-4.66</td><td>64</td><td>1.43</td><td>1024</td><td>0.63</td><td>-99.85</td><td></td><td>-39.31</td><td></td><td>128</td></tr><tr><td>cardiotocography</td><td>10.55</td><td>59.52</td><td>512</td><td>31.04</td><td>1024</td><td></td><td>9.85</td><td>54.34</td><td>32</td><td>56.08</td><td>128</td></tr><tr><td>magic-telescope</td><td>102.53</td><td>-3.65</td><td>512</td><td>-5.03</td><td>1024</td><td></td><td>3.74</td><td>-3.97</td><td>8</td><td>-4.22</td><td>8</td></tr><tr><td>pendigits</td><td>4.89</td><td>0.88</td><td>1024</td><td>-4.86</td><td>16384</td><td></td><td>4.17</td><td>1.46</td><td>8</td><td>0.48</td><td>8</td></tr><tr><td>pima-indians</td><td>0.37</td><td>-8.54</td><td>64</td><td>-7.62</td><td></td><td>64</td><td>1.35</td><td>-20.09</td><td>128</td><td>-16.33</td><td>128</td></tr><tr><td>wall-following-robot</td><td>3.43</td><td>1.84</td><td>1024</td><td>-11.3</td><td>16384</td><td></td><td>22.21</td><td>-14.26</td><td>128</td><td>-17.56</td><td>128</td></tr><tr><td>waveform-1</td><td>4.35</td><td>-26.14</td><td>64</td><td>-23.91</td><td>1024</td><td></td><td>3.72</td><td>-34.12</td><td>8</td><td>-33.42</td><td>8</td></tr><tr><td>waveform-2</td><td>4.82</td><td>-26.21</td><td>64</td><td>-23.91</td><td></td><td>1024</td><td>4.12</td><td>-34.15</td><td>8</td><td>-33.64</td><td>8</td></tr><tr><td>yeast</td><td>20.57</td><td>10.26</td><td>512</td><td>5.18</td><td>1024</td><td></td><td>14.49</td><td>6.61</td><td>128</td><td>9.59</td><td>128</td></tr><tr><td>ecoli</td><td>1.86</td><td>-5.5</td><td>64</td><td>-0.22</td><td>1024</td><td></td><td>2.15</td><td>-11.37</td><td>128</td><td>-10.64</td><td>128</td></tr><tr><td>ionosphere</td><td>1.88</td><td>-20.27</td><td>64</td><td>-5.93</td><td></td><td>512</td><td>2.74</td><td>-87.01</td><td>128</td><td>-42.75</td><td>128</td></tr><tr><td>iris</td><td>0.23</td><td>-10.65</td><td>64</td><td>-1.49</td><td>16384</td><td></td><td>3.28</td><td>-16.34</td><td>128</td><td>-9.21</td><td>32</td></tr><tr><td>page-blocks</td><td>12.18</td><td>12.21</td><td>512</td><td>6.84</td><td>1024</td><td></td><td>44.95</td><td>17.13</td><td>128</td><td>17.94</td><td>32</td></tr><tr><td>parkinsons</td><td>1.46</td><td>-21.85</td><td>64</td><td>0.5</td><td></td><td>512</td><td>3.09</td><td>-566.58</td><td>128</td><td>-33.31</td><td>32</td></tr><tr><td>sonar</td><td>2.96</td><td>-95.39</td><td>512</td><td>-69.29</td><td></td><td>64</td><td>2.52</td><td>-622.2</td><td>128</td><td>-88.81</td><td>128</td></tr><tr><td>statlog-segment</td><td>1.44</td><td>47.35</td><td>512</td><td>26.53</td><td>16384</td><td></td><td>38.49</td><td>35.84</td><td>128</td><td>42.04</td><td>32</td></tr><tr><td>statlog-vehicle</td><td>2.97</td><td>-4.25</td><td>64</td><td>-5.45</td><td>1024</td><td></td><td>6.78</td><td>-31.34</td><td>32</td><td>-26.43</td><td>128</td></tr><tr><td>wine rank</td><td>75.42</td><td>-25.99</td><td>1024</td><td>-13.27</td><td></td><td>1024</td><td>2.05</td><td>-171.58</td><td>128</td><td>-25.57</td><td>128</td></tr><tr><td></td><td></td><td>1.56</td><td></td><td>1.44</td><td></td><td></td><td></td><td>1.83</td><td></td><td>1.17</td><td></td></tr></table>
+
+298 Experimental settings: We use the same experimental settings and evaluation metrics as in Section   
+299 6.2. We apply the mixture model on all datasets, changing the number of components as follows:   
+300 $K \in ( 8 , 3 2 , 1 2 8 )$ . Each real NVP-based component in the mixture model has (i) the translation   
+301 function parameterized via multi-layer perceptron with a single hidden layer of dimension 10, using   
+302 the rectified linear activation function; and (ii) the scale function parameterized via the same network   
+303 except with the hyperbolic tangent activation function. We do not use the batch normalization [15] and   
+304 we stack two layers of the translation-scale transformation (we have used implementation from [20]).
+
+Algorithms: The algorithms and their settings are the same as those in Section 6.2.
+
+306 Results: The experimental results are presented in right part of Table 6.2. They are similar to those   
+307 obtained in the previous section. In terms of the test log-likelihood, the MHSAEM-U algorithm   
+308 outperforms the SGD algorithm on all but three datasets, and it provides a substantial speed-up on all   
+309 datasets except one. The test likelihood of models with the real NVP flows is most of the time worse   
+310 than that of SPTNs with the affine transformations. As explained in the supplementary, this is due to   
+311 the overfitting, which has been observed in [47].
+
+# 312 7 Conclusion
+
+313 This paper has presented a method to decrease computational complexity of fitting mixture models,   
+314 including their generalizations, such as sum-product-(transform) networks and mixtures of flow   
+315 models. The speed-up is achieved by evaluating and updating only a single component (per iteration),   
+316 where the Metropolis-Hasting algorithm ensures sampling of components from a proper posterior. An   
+317 experimental comparison on all three classes of models mentioned above confirmed the theoretical   
+318 expectations. The method significantly speeds-up the fitting time and, importantly, without sacrificing   
+319 the quality of the fit. In fact, the likelihood was better than that of the models fitted by the EM   
+320 algorithm or the SGD algorithm in more than $50 \%$ of cases. We attribute this to higher stochasticity,   
+321 which helps to escape from poor local minima.   
+322 In the experiments, the proposed method has used a uniform proposal distribution in the MH sampler.   
+323 Despite outperforming the alternative methods, we conjecture that this limits the speed of convergence.   
+324 Therefore, we believe that there is still a room for improvement in the implementation. We plan to   
+325 address these issues in future work.
+
+The presented method decreases the computational complexity of fitting large (and deep) mixture models, which leads to five to hundred time speed-up depending on a size of the problem (although negative exceptions occurs). We believe this line of research, which we want to continue, to have important benefits. First, it is directly related to decrease in energy consumption and in production of CO2 (we expect similar rates as the speedup). Second, it has a positive effect on financial aspects of deploying (and experimenting with) mixture models. Third, it decreases the hardware requirements, as in all experiments presented above the model was fitted on a single-core.
+
+# References
+
+[1] S. Allassonnière and J. Chevallier. A new class of stochastic EM algorithms: Escaping local maxima and handling intractable sampling. Computational Statistics & Data Analysis, 159:107159, 2021.   
+[2] S. Ayesha, M. K. Hanif, and R. Talib. Overview and comparative study of dimensionality reduction techniques for high dimensional data. Information Fusion, 59:44–58, 2020.   
+[3] D. S. Bai. Efficient estimation of transition probabilities in a Markov chain. The Annals of Statistics, pages 1305–1317, 1975.   
+[4] D. M. Blei, A. Kucukelbir, and J. D. McAuliffe. Variational inference: A review for statisticians. Journal of the American statistical Association, 112(518):859–877, 2017.   
+[5] J. Blömer and K. Bujna. Adaptive seeding for Gaussian mixture models. In Pacific-asia conference on knowledge discovery and data mining, pages 296–308. Springer, 2016.   
+[6] T. Campbell and B. Beronov. Sparse variational inference: Bayesian coresets from scratch. arXiv preprint arXiv:1906.03329, 2019.   
+[7] O. Cappé and E. Moulines. On-line expectation–maximization algorithm for latent data models. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 71(3):593–613, 2009.   
+[8] J. Chen, J. Zhu, Y. Teh, and T. Zhang. Stochastic expectation maximization with variance reduction. Advances in Neural Information Processing Systems, page 7967, 2018.   
+[9] N. Chopin. A sequential particle filter method for static models. Biometrika, 89(3):539–552, 2002.   
+[10] G. Compiani and Y. Kitamura. Using mixtures in econometric models: A brief review and some new results. The Econometrics Journal, 19(3):C95–C127, 2016.   
+[11] S. Dasgupta. Learning mixtures of Gaussians. In 40th Annual Symposium on Foundations of Computer Science (Cat. No. 99CB37039), pages 634–644. IEEE, 1999.   
+[12] B. Delyon, M. Lavielle, E. Moulines, et al. Convergence of a stochastic approximation version of the EM algorithm. The Annals of Statistics, 27(1):94–128, 1999.   
+[13] A. P. Dempster, N. M. Laird, and D. B. Rubin. Maximum likelihood from incomplete data via the EM algorithm. Journal of the Royal Statistical Society: Series B (Methodological), 39(1):1–22, 1977.   
+[14] J. Demšar. Statistical comparisons of classifiers over multiple data sets. The Journal of Machine Learning Research, 7:1–30, 2006.   
+[15] L. Dinh, J. Sohl-Dickstein, and S. Bengio. Density estimation using real NVP. In 5th International Conference on Learning Representations, ICLR 2017, 2017.   
+[16] D. Dua and C. Graff. UCI machine learning repository, 2017.
+
+[17] D. Feldman, M. Faulkner, and A. Krause. Scalable training of mixture models via coresets. In Proceedings of the 24th International Conference on Neural Information Processing Systems, pages 2142–2150, 2011. 372 [18] D. Forster and J. Lücke. Can clustering scale sublinearly with its clusters? A variational EM acceleration of GMMs and k-means. In International Conference on Artificial Intelligence and Statistics, pages 124–132. PMLR, 2018. [19] G. Fort, E. Moulines, et al. Convergence of the Monte Carlo expectation maximization for curved exponential families. Annals of Statistics, 31(4):1220–1259, 2003. [20] J. Franc˚u. Continuousflows.jl. https://github.com/janfrancu/ContinuousFlows.jl, 2020. [21] K. Greff, S. van Steenkiste, and J. Schmidhuber. Neural expectation maximization. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 6694–6704, 2017. [22] R. Gribonval, A. Chatalic, N. Keriven, V. Schellekens, L. Jacques, and P. Schniter. Sketching datasets for large-scale learning (long version). arXiv preprint arXiv:2008.01839, 2020. [23] M. D. Hoffman, D. M. Blei, C. Wang, and J. Paisley. Stochastic variational inference. Journal of Machine Learning Research, 14(5), 2013. [24] M. C. Hughes and E. B. Sudderth. Fast learning of clusters and topics via sparse posteriors. arXiv preprint arXiv:1609.07521, 2016. [25] K. Humphreys and D. Titterington. Approximate Bayesian inference for simple mixtures. In COMPSTAT, pages 331–336. Springer, 2000. [26] B.-H. Juang and L. R. Rabiner. The segmental K-means algorithm for estimating parameters of hidden Markov models. IEEE Transactions on acoustics, speech, and signal Processing, 38(9):1639–1641, 1990. [27] B. Karimi, M. Lavielle, and É. Moulines. On the convergence properties of the mini-batch EM and MCEM algorithms, 2019. [28] N. Keriven, A. Bourrier, R. Gribonval, and P. Pérez. Sketching for large-scale learning of mixture models. Information and Inference: A Journal of the IMA, 7(3):447–508, 2018. [29] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [30] A. Kucukelbir, D. Tran, R. Ranganath, A. Gelman, and D. M. Blei. Automatic differentiation variational inference. The Journal of Machine Learning Research, 18(1):430–474, 2017. [31] E. Kuhn and M. Lavielle. Coupling a stochastic approximation version of EM with an MCMC procedure. ESAIM: Probability and Statistics, 8:115–131, 2004. [32] E. Kuhn, C. Matias, and T. Rebafka. Properties of the stochastic approximation EM algorithm with mini-batch sampling. Statistics and Computing, 30(6):1725–1739, 2020. [33] A. Lagrange, M. Fauvel, and M. Grizonnet. Large-scale feature selection with Gaussian mixture models for the classification of high dimensional remote sensing images. IEEE Transactions on Computational Imaging, 3(2):230–242, 2017. [34] M. Lavine and M. West. A Bayesian method for classification and discrimination. Canadian Journal of Statistics, 20(4):451–461, 1992. [35] M. Little, P. McSharry, S. Roberts, D. Costello, and I. Moroz. Exploiting nonlinear recurrence and fractal scaling properties for voice disorder detection. Nature Precedings, pages 1–1, 2007. [36] R. Maitra and V. Melnykov. Simulating data to study performance of finite mixture modeling and clustering algorithms. Journal of Computational and Graphical Statistics, 19(2):354–376, 2010.
+
+15 [37] O. L. Mangasarian and W. H. Wolberg. Cancer diagnosis via linear programming. Technical report, University of Wisconsin-Madison Department of Computer Sciences, 1990.   
+17 [38] J.-M. Marin, K. Mengersen, and C. P. Robert. Bayesian modelling and inference on mixtures of distributions. Handbook of statistics, 25:459–507, 2005.   
+19 [39] C. A. McGrory, D. C. Ahfock, J. A. Horsley, and C. L. Alston. Weighted Gibbs sampling for mixture modelling of massive datasets via coresets. Stat, 3(1):291–299, 2014. [40] G. J. McLachlan, S. X. Lee, and S. I. Rathnayake. Finite mixture models. Annual review of statistics and its application, 6:355–378, 2019.   
+423 [41] V. Melnykov, W.-C. Chen, and R. Maitra. MixSim: An R package for simulating data to study performance of clustering algorithms. Journal of Statistical Software, 51(12):1, 2012.   
+25 [42] T. Monnier, T. Groueix, and M. Aubry. Deep transformation-invariant clustering. In Conference on Neural Information Processing Systems (NeurIPS 2020), 2020. [43] I. Naim and D. Gildea. Convergence of the EM algorithm for Gaussian mixtures with unbalanced mixing coefficients. In Proceedings of the 29th International Coference on International Conference on Machine Learning, pages 1427–1431, 2012. [44] H. D. Nguyen, F. Forbes, and G. J. McLachlan. Mini-batch learning of exponential family finite mixture models. Statistics and Computing, pages 1–18, 2020. [45] R. Peharz, A. Vergari, K. Stelzner, A. Molina, X. Shao, M. Trapp, K. Kersting, and Z. Ghahramani. Random sum-product networks: A simple and effective approach to probabilistic deep learning. In Uncertainty in Artificial Intelligence, pages 334–344. PMLR, 2020. [46] T. Pevný. Loda: Lightweight on-line detector of anomalies. Machine Learning, 102(2):275–304, 2016. [47] T. Pevný, V. Šmídl, M. Trapp, O. Polácek, and T. Oberhuber. Sum-product-transform networks: ˇ Exploiting symmetries using invertible transformations. arXiv preprint arXiv:2005.01297, 2020. [48] G. G. Pires and M. A. Figueiredo. Variational mixture of normalizing flows. arXiv preprint arXiv:2009.00585, 2020.   
+42 [49] A. Rau, C. Maugis-Rabusseau, M.-L. Martin-Magniette, and G. Celeux. Co-expression analysis of high-throughput transcriptome sequencing data with Poisson mixture models. Bioinformatics, 31(9):1420–1427, 2015.   
+45 [50] R. A. Redner and H. F. Walker. Mixture densities, maximum likelihood and the EM algorithm. SIAM review, 26(2):195–239, 1984.   
+47 [51] H. Robbins and S. Monro. A stochastic approximation method. The annals of mathematical statistics, pages 400–407, 1951.   
+49 [52] C. Robert and G. Casella. Monte Carlo statistical methods. Springer Science & Business Media, 2013. [53] W. Siblini, P. Kuntz, and F. Meyer. A review on dimensionality reduction for multi-label classification. IEEE Transactions on Knowledge and Data Engineering, 2019.   
+53 [54] J. P. Siebert. Vehicle recognition using rule based methods. 1987. [55] C. Viroli and G. J. McLachlan. Deep gaussian mixture models. Statistics and Computing, 29(1):43–51, 2019.   
+56 [56] C. F. J. Wu. On the convergence properties of the EM algorithm. The Annals of statistics, pages 95–103, 1983.   
+58 [57] D. Wu and J. Ma. An effective EM algorithm for mixtures of Gaussian processes via the MCMC sampling and approximation. Neurocomputing, 331:366–374, 2019.
+
+60 [58] W. Xiang, A. Karfoul, C. Yang, H. Shu, and R. L. B. Jeannès. An exact line search scheme to   
+61 accelerate the EM algorithm: Application to Gaussian mixture models identification. Journal of   
+62 computational science, 41:101073, 2020.   
+63 [59] M. Zhang, Y. Fu, K. M. Bennett, and T. Wu. Computational efficient variational Bayesian Gaus  
+64 sian mixture models via coreset. In 2016 International Conference on Computer, Information   
+65 and Telecommunication Systems (CITS), pages 1–5. IEEE, 2016.   
+66 [60] H. Zhao, P. Poupart, and G. Gordon. A unified approach for learning the parameters of sum  
+67 product networks. In Proceedings of the 30th International Conference on Neural Information   
+68 Processing Systems, pages 433–441, 2016.
+
+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] Our main contribution is computational speedup. Cases where it was not achieved are highlighted in the experimental section.   
+(c) Did you discuss any potential negative societal impacts of your work? [No] We do not foresee any potential negative impact.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The code is available in a github repository. All dataset are public from the UCI database.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 6.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We report only average of Monte Carlo repetitions, the error bars were too small to have any visual impact in the reported logarithmic scale.   
+(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 20 datasets from UCI, we cite the required papers for each dataset, mostly the UCI database and few additional publications.   
+(b) Did you mention the license of the assets? [No] The data are publically available, we comply with the requirement on citing appropriate publications.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [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/ki4eJ1fSJNq/ki4eJ1fSJNq_content_list.json

@@ -0,0 +1,1195 @@
+[
+    {
+        "type": "text",
+        "text": "Fitting large mixture models using stochastic component selection ",
+        "text_level": 1,
+        "bbox": [
+            228,
+            122,
+            769,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Traditional methods for unsupervised learning of finite mixture models require to   \n2 evaluate the likelihood of all components of the mixture. This becomes computa  \n3 tionally prohibitive when the number of components is large, as it is, for example,   \n4 in the sum-product (transform) networks. As a remedy, we propose an approach   \n5 combining the expectation maximization and the Metropolis-Hastings algorithm   \n6 to evaluate only a small number of, stochastically sampled, components, thus   \n7 substantially reducing the computational cost. We put emphasis on generality of   \n8 our method, equipping it with the ability to train both shallow and deep mixture   \n9 models which involve complex, and possibly nonlinear, transformations. The   \n10 performance of our method is illustrated in a variety of synthetic and real-data   \n11 contexts, considering deep models, such as mixtures of normalizing flows and   \n12 sum-product (transform) networks. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "13 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            539,
+            312,
+            556
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "14 Finite mixture models [40] constitute a fundamental class of density estimation models. They   \n15 have been successfully applied in diverse fields, including bioinformatics [49], econometrics [10],   \n16 engineering [33], etc. A mixture model relies on a weighted sum of probability distributions—here   \n17 referred to as components—to cluster $N$ unlabelled datapoints into $K$ categories. The traditional   \n18 maximum likelihood techniques train the model by optimizing either (i) the marginal likelihood via   \n19 gradient-descent [50] or (ii) the evidence lower bound via variational methods [4], including the   \n20 expectation-maximization (EM) [13]. The dependence structure among approximate, variational,   \n21 distributions then ranges from the fully independent (mean-field) [25] to fully dependent [30]. The   \n22 sampling-based techniques target the posterior distribution using sequential Monte Carlo [9] or   \n23 Markov chain Monte Carlo [52], e.g. via the Gibbs [34] or Metropolis-Hastings sampling [38]. The   \n24 computational cost of these methods typically scales with $\\mathcal { O } ( T K N D )$ operations, where $N$ and $K$   \n25 are defined above, $T$ is the number of iterations and $D$ is the dimension of data.   \n26 Various methods to decrease the computational cost via any factor in $\\mathcal { O } ( T K N D )$ have been proposed.   \n27 $T$ can be lowered by proper initialization, e.g. the optimal seeding [5]; an efficient step-size schedule,   \n28 e.g. the line-search [58]; or increased estimation precision, e.g. the variance reduction [8]. $N$ is often   \n29 reduced using the coreset methods, which approximate the original dataset by a weighted dataset   \n30 such that the exact and approximate marginal likelihoods are close. The weighted variants of the   \n31 variational [17, 59, 6] and sampling-based [39] methods then process the coresets. Reducing $D$ relies   \n32 on the compression of data into smaller representations via random projections [53, 2], which is   \n33 achieved in two ways: (i) each data item is projected into an individual representation [11]; (ii) all   \n34 data items are projected into an overall representation, commonly referred to as sketch [28, 22].   \n35 Nevertheless, all the aforementioned techniques—including those with reduced computational cost—   \n36 evaluate all $K$ components. This is very demanding for large models, and the problem is even more   \n37 severe for mixtures involving intricate models, such as neural networks [21, 42], Gaussian processes   \n38 [57], normalizing flows [48]; or deep mixtures, including sum-product (transform) networks [45, 47],   \n39 deep Gaussian mixture models [55], etc. In spite of this, a little attention has been paid to the design   \n40 of algorithms which does not evaluate all $K$ components. The notable exceptions are the sparse EM   \n41 algorithm [24] and the truncated variational EM algorithm [18], see Table 1 and Section 5 for details.   \n42 Moreover, the methods are mostly tailored for a specific class of mixture models, e.g. the Gaussian   \n43 mixture models. ",
+        "bbox": [
+            147,
+            570,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            742,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            873,
+            828,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "table",
+        "img_path": "images/5e346a33d4bf96097d66d042d2edb3a796cd7475f2111dc5b8813d4424db6d24.jpg",
+        "table_caption": [
+            "Table 1: The computational features of various EM algorithms. We compare whether the methods (i) perform the computations with a reduced number of data (minibatching), (ii) update a lower number of statistics, (iii) make less evaluations of the conditional likelihood, and (iv) are suitable for training of deep models. Here, EM, SA, S, T, MC and MH stand for expectation-maximization, stochastic approximation, sparse, truncated, Monte Carlo and Metropolis-Hastings, respectively. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Feature/Algorithm</td><td>EM [13]</td><td>SAEM [44]</td><td>SSAEM [24]</td><td>TSAEM [18]</td><td>MCSAEM [1]</td><td>MHSAEM (ours)</td></tr><tr><td>B&lt;Ndatapoints</td><td>×</td><td></td><td></td><td>√</td><td></td><td></td></tr><tr><td>M&lt;K statistics</td><td>xx</td><td></td><td></td><td></td><td>厂</td><td></td></tr><tr><td>M&lt;Klikelihoods</td><td></td><td>xx</td><td>×</td><td></td><td>X</td><td></td></tr><tr><td>deep models</td><td>×</td><td>×</td><td>×</td><td>X</td><td>×</td><td></td></tr></table>",
+        "bbox": [
+            222,
+            165,
+            774,
+            244
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            273,
+            826,
+            372
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "44 In this paper, we make the following contributions: ",
+        "bbox": [
+            147,
+            377,
+            509,
+            392
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "45 • We propose an EM-based algorithm which relies on the MH sampler to stochastically evaluate less   \n46 components in mixture models, substantially reducing the computational cost.   \n7 • We design our method to enable optimization of fairly generic EM objective functions, making it   \n48 suitable for training of both shallow and deep mixture models.   \n49 • We apply our approach to Gaussian mixture mdoels (GMMs) and their generalizations: sum  \n50 product-transform networks (SPTNs) and mixtures of real-valued non-volume preserving (real   \n51 NVP) flows [15], reaching approximately $1 0 0 \\times$ speed-up compared to state-of-the-art methods. ",
+        "bbox": [
+            151,
+            405,
+            825,
+            434
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            441,
+            823,
+            472
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            479,
+            825,
+            522
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "52 2 Problem formulation ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            553,
+            382,
+            570
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A finite mixture model characterizes the relation between an observed (known) variable, 53 $\\boldsymbol { x } \\in \\times \\subseteq \\mathbb { R } ^ { D }$ , 54 and a latent (unknown) variable, $z \\in Z : = \\{ 1 , \\dots , K \\}$ , via the marginal (incomplete-data) likelihood 55 in the following form: ",
+        "bbox": [
+            147,
+            587,
+            825,
+            630
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1fd8c64bc931f74af8171cacb46094a19b2d53d8b9408dc1581f5a44dfea91a9.jpg",
+        "text": "$$\np _ { \\theta } ( x ) = \\sum _ { k = 1 } ^ { K } p _ { \\eta _ { k } } ( x | z = k ) p _ { \\pi _ { k } } ( z = k ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            633,
+            627,
+            678
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "56 where $\\theta : = ( \\pi _ { 1 } , \\eta _ { 1 } , \\dots , \\pi _ { K } , \\eta _ { K } ) \\in \\Theta$ are unknown parameters. Here, $\\eta _ { z }$ are the parameters of the 57 conditional likelihood, $p _ { \\eta _ { z } } ( x | z )$ , and $\\pi _ { z }$ is the weight which parameterizes the prior, $p _ { \\pi _ { z } } ( z ) = \\pi _ { z }$ , and satisfies 58 $0 \\leq \\pi _ { k } \\leq 1$ for each $k \\in { \\mathord { \\mathbb { Z } } }$ and $\\textstyle \\sum _ { k = 1 } ^ { K } \\pi _ { k } = 1$ . ",
+        "bbox": [
+            145,
+            685,
+            826,
+            734
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "59 Given a set of independent and identically distributed data, $\\mathbf { x } : = ( x _ { i } ) _ { i = 1 } ^ { N }$ , our goal is to learn the   \n60 unknown parameters of the marginal log-likelihood, ",
+        "bbox": [
+            148,
+            739,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a533a8160c37e7b9fa1209ffe45b29c0eb14f6404e4bc9e51f2458ababc808c.jpg",
+        "text": "$$\n\\mathcal { L } ( \\theta ) : = \\log p _ { \\theta } ( \\mathbf { x } ) = \\sum _ { i = 1 } ^ { N } \\log \\sum _ { k = 1 } ^ { K } p _ { \\eta _ { k } } ( x _ { i } | z _ { i } = k ) p _ { \\pi _ { k } } ( z _ { i } = k ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            295,
+            780,
+            700,
+            824
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "61 The marginalization in (2) is tractable for almost all forms of $p _ { \\eta _ { z } } ( x | z )$ . Indeed, we consider $p _ { \\eta _ { z } } ( x | z )$   \n62 to belong to an arbitrary family of $\\eta _ { z }$ -differentiable probability distributions. However, we assume that   \n63 $K$ is high, making the marginalization in (2) computationally costly, thus rendering the optimization   \n64 objective presumably intractable. Therefore, we want to design a computationally efficient algorithm,   \n65 requiring only $M < K$ evaluations of $p _ { \\eta _ { z } } ( x | z )$ at each iteration.   \n67 The maximum likelihood estimation seeks the parameters maximizing the marginal log-likelihood,   \n68 $\\theta ^ { M L } : = \\arg \\operatorname* { m a x } _ { \\theta \\in \\Theta } \\mathcal { L } ( \\theta )$ . The traditional EM algorithm [13] addresses this task indirectly, i.e. by   \n69 optimizing the evidence lower bound (ELBO), ",
+        "bbox": [
+            147,
+            840,
+            826,
+            912
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            121,
+            825,
+            162
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df55efbf1dd9a5a5ef40f11a29cb92a7c818d04135e3c849687eb5724cd486b5.jpg",
+        "text": "$$\n\\mathcal { L } ( \\theta ) \\geq \\mathcal { Q } ( \\theta ) + \\mathcal { H } ( \\hat { \\theta } ) : = \\mathrm { E L B O } ( \\hat { \\theta } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            170,
+            619,
+            189
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where 70 $\\mathcal { H } ( \\hat { \\theta } ) : = - \\mathsf E _ { p _ { \\hat { \\theta } } ( \\mathbf { z } | \\mathbf { x } ) } [ \\log p _ { \\hat { \\theta } } ( \\mathbf { z } | \\mathbf { x } ) ]$ is the differential entropy at an estimate, $\\hat { \\theta } \\in \\Theta$ , and ",
+        "bbox": [
+            140,
+            198,
+            771,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8dc49814f958acdf8ce0e11b963a6e6101e3e5d1439603310c411ba01588b3e9.jpg",
+        "text": "$$\n\\mathcal { Q } ( \\theta ) : = \\mathsf { E } _ { p _ { \\hat { \\theta } } ( \\mathbf { z } | \\mathbf { x } ) } [ \\log p _ { \\theta } ( \\mathbf { z } , \\mathbf { x } ) ] = \\sum _ { i = 1 } ^ { N } \\sum _ { k = 1 } ^ { K } p _ { \\theta } ( z _ { i } = k | x _ { i } ) \\log p _ { \\theta } ( z _ { i } = k , x _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            254,
+            222,
+            743,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "71 is the EM objective function. Here, $p _ { \\theta } ( \\mathbf { z } , \\mathbf { x } )$ is the joint (complete-data) likelihood, and $p _ { \\theta } ( \\mathbf { z } | \\mathbf { x } )$ is   \n72 the posterior distribution over the latent variables $\\dot { \\mathbf { z } } : = ( z _ { i } ) _ { i = 1 } ^ { N }$ . Given an initial value, $\\theta _ { 0 }$ , the EM   \n73 algorithm produces a sequence of estimates, $( \\theta _ { t } ) _ { t = 1 } ^ { T }$ , by alternating between the expectation (E) and   \n74 maximization (M) steps, ",
+        "bbox": [
+            145,
+            273,
+            825,
+            332
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b0f69e94b819f6dec2b2f46df7d892633bd8e60b66ed31dbb1985f882bcb2f60.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathrm { E \\mathrm { - } s t e p } ; ~ \\mathcal { Q } _ { t - 1 } ( \\theta ) , } \\\\ & { \\mathrm { M \\mathrm { - } s t e p } ; ~ \\theta _ { t } : = \\arg \\operatorname* { m a x } _ { \\theta \\in \\Theta } \\mathcal { Q } _ { t - 1 } ( \\theta ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            337,
+            607,
+            382
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "75 This sequence is guaranteed to monotonically tighten the ELBO, arriving at a local optimum of (2)   \n76 under mild regularity assumptions [56].   \n77 The EM algorithm is computationally expensive, since (4) evaluates $p _ { \\theta } ( z _ { i } , x _ { i } )$ for each $z _ { i } \\in \\mathbb { Z }$ and   \n78 $i \\in ( 1 , \\ldots , N )$ . This has to be performed for all $t \\in ( 1 , \\ldots , T )$ in (5). Albeit the marginal factor,   \n79 $p _ { \\pi _ { z } } ( z )$ , is just the cheap categorical distribution, the conditional factor, $p _ { \\eta _ { z } } ( x | z )$ , typically involves   \n80 high-dimensional operations (e.g., the inversion of the full $D \\times D$ -dimensional covariance matrices   \n81 in the GMMs). Moreover, the M-step (6) is also expensive for large $K$ . This holds despite that (6)   \n82 can be reduced to closed-form updates of expected sufficient statistics for $p _ { \\eta _ { z } } ( x | z )$ belonging to the   \n83 exponential family [44] (again, due to high $D$ ). All in all, the computational complexity of the EM   \n84 algorithm scales with $\\mathcal { O } ( T D N K )$ . ",
+        "bbox": [
+            143,
+            388,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            422,
+            825,
+            535
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If (6) cannot be computed under a closed-form solution, one can resort to direct gradient-descent optimization of $\\mathcal { Q } ( \\boldsymbol { \\theta } )$ , where arg max is replaced by one (or more) step(s) of a gradient descent technique. The EM algorithm is then referred to as the generalized EM algorithm [56]. ",
+        "bbox": [
+            160,
+            540,
+            823,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "88 4 The generalized MHSAEM algorithm ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            602,
+            521,
+            619
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "89 We design a version of the generalized EM algorithm suitable for scenarios where (4) can represent   \n90 deep, discrete, latent variable models, thus being parameterized by possibly complex nonlinear   \n91 transformations. We particularly focus on decreasing the the number of operations in the generalized   \n92 EM algorithm from $\\mathcal { O } ( T D N K )$ to $\\mathcal { O } ( T D B M )$ , where $B \\ll N$ and $M \\ll K$ . ",
+        "bbox": [
+            147,
+            633,
+            825,
+            690
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 E-step ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            705,
+            256,
+            720
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "94 We reduce the cost of evaluating the EM objective function (4) by combining the minibatching (as   \n95 used many times before) and the Monte Carlo sampling. Namely, the specific application of the latter   \n96 to generic mixture models is the key contribution of this paper.   \n97 Minibatching. At each iteration, $t$ , we compute the conditional expectation in (4) only for a subset—   \n98 here referred to as a minibatch—of the original full dataset, i.e. $( x _ { i } ) _ { i \\in I }$ . Here, $I$ is a set of $B \\ll N$   \n99 indices, $i$ , sampled uniformly without replacement from $( 1 , \\ldots , \\dot { N } )$ . This substantially decreases the   \n100 necessary computations compared to the full sweep over all $N$ datapoints [23].   \n101 Monte Carlo sampling. For each $i \\in I$ , we want to draw $M \\ll K$ random samples from $p _ { \\theta } ( z _ { i } | x _ { i } )$ in   \n102 order to obtain a Monte Carlo estimate of (4). The straightforward way to do this would be to draw   \n103 the samples directly from $p _ { \\theta } ( z _ { i } | x _ { i } )$ . However, direct sampling from $p _ { \\theta } ( z _ { i } | x _ { i } )$ does not lead to any   \n104 substantial decrease in the number of operations. This is caused by the fact that even for a single   \n105 sample of $z _ { i }$ , we have to first compute the normalizing factor, $p _ { \\theta } ( x _ { i } )$ , to obtaining the posterior,   \n106 $p _ { \\theta } ( z _ { i } | x _ { i } )$ . This requires $K$ expensive evaluations of $p _ { \\theta } ( z _ { i } , x _ { i } )$ , which is precisely what we want to   \n107 avoid. Our approach is to resort to the Markov chain Monte Carlo (MCMC), which allows us to   \n108 sample from $p _ { \\theta } ( z _ { i } | x _ { i } )$ , with the computational complexity decreasing to only a single evaluation of   \n109 $p _ { \\theta } ( z _ { i } , x _ { i } )$ per a single sample of $z _ { i }$ .   \n110 MCMC methods obviate the computation of the normalizing factor in $p _ { \\theta } ( z _ { i } | x _ { i } )$ by simulating a   \n111 Markov chain, $( z _ { i , t } ) _ { t = 1 } ^ { T }$ , from a transition kernel, $z _ { i , t } \\sim P ( z _ { i , t - 1 } , \\cdot )$ , which leaves $p _ { \\theta } ( z _ { i } | x _ { i } )$ as its   \n112 unique stationary (invariant) distribution, starting from an initial value $z _ { i , 0 }$ . The specific form of $P$   \n113 determines the structure of an MCMC method. We chose the Metropolis-Hastings (MH) sampler,   \n114 which represents $P ( z _ { i , t - 1 } , z _ { i , t } )$ as follows: given $\\bar { z } _ { i } : = z _ { i , t - 1 }$ , draw a sample from the proposal   \n115 distribution $z _ { i } \\sim q ( \\cdot | \\bar { z } _ { i } )$ , compute the acceptance ratio, ",
+        "bbox": [
+            147,
+            731,
+            825,
+            773
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            779,
+            825,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            90,
+            825,
+            147
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            152,
+            825,
+            238
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e2865ff49fb5c3c34577e0a148cbc695663514dff1302f39bca47fd492f0e3e.jpg",
+        "text": "$$\n\\alpha ( \\bar { z } _ { i } , z _ { i } ) : = \\operatorname* { m i n } \\biggr \\{ 1 , \\frac { p _ { \\eta _ { z _ { i } , t - 1 } } ( x _ { i } | z _ { i } ) \\pi _ { z _ { i } , t - 1 } q ( \\bar { z } _ { i } | z _ { i } ) } { p _ { \\eta _ { \\bar { z } _ { i } , t - 1 } } ( x _ { i } | \\bar { z } _ { i } ) \\pi _ { \\bar { z } _ { i } , t - 1 } q ( z _ { i } | \\bar { z } _ { i } ) } \\biggr \\} ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            321,
+            241,
+            676,
+            279
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "116 and, if $u < \\alpha \\big ( \\bar { z } _ { i } , z _ { i } \\big )$ —where $u$ is drawn from a uniform distribution, Uniform $( 0 , 1 )$ —accept the   \n117 sample and set $z _ { i , t } = z _ { i }$ ; otherwise, set $z _ { i , t } = \\bar { z } _ { i }$ . For each $i \\in I$ and $t \\in ( 1 , \\ldots , T )$ , we repeat   \n118 this process $M$ times, construing a set $\\mathbf { z } _ { i , t } = ( z _ { i , t } ^ { 1 } , \\dots , z _ { i , t } ^ { M } )$ . Therefore, at every current iteration,   \n119 120 $t$ , we caking $\\bar { z } _ { i } = z _ { i , t - 1 } ^ { M }$ extend the chain from the point where we left at the previous iteration, . Under mild regularity assumptions [52], the chain passes the transiti $t - 1$ , byriod   \n121 (the burn-in phase), and the samples can then be used to approximate the conditional expectation in   \n122 (4) as follows: ",
+        "bbox": [
+            140,
+            282,
+            825,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e43005c66ee8eb883ede3aeefb994947aa4f14879ab1b3689fc3176b2f635909.jpg",
+        "text": "$$\n\\widehat { \\mathcal { Q } } _ { t - 1 } ( \\theta ) = \\frac { 1 } { M } \\sum _ { i \\in I } \\sum _ { z \\in \\mathbf { z } _ { i , t } } \\log p _ { \\eta _ { z } } ( x _ { i } | z ) \\pi _ { z } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            378,
+            637,
+            419
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "123 Note that, to ensure this approach is truly efficient, we have to draw only $M \\ll K$ samples at each   \n124 iteration, $t$ ; otherwise, for $M \\approx K$ , we may rather compute the exact marginalization in (4), since it   \n125 is tractable (but computationally costly). ",
+        "bbox": [
+            142,
+            420,
+            825,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 M-step ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            478,
+            263,
+            493
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "127 Assume for a moment that (6) with $\\mathcal { Q } _ { t - 1 } ( \\theta )$ given by (8) has a closed-form solution, yielding an   \n128 estimate of $\\theta$ . Such an estimate would have a high variance, converging only for $M \\to \\infty$ and   \n129 $T \\to \\infty$ [19]. The main reason is that the samples would not be reused over the iterations, $t$ ,   \n130 thus wasting computational resources. We consider that there is no closed-form solution of (6),   \n131 and—to ensure that the samples (and thus computations) are recycled over the iterations—we use   \n132 the stochastic approximation (SA) [51] to optimize (8). This is analogous to applying a stochastic   \n133 gradient-descent method, $\\theta _ { t } = \\theta _ { t - 1 } + \\gamma _ { t } \\nabla _ { \\theta } \\tilde { \\mathcal { Q } } _ { t - 1 } ( \\theta )$ , where $\\gamma _ { t }$ is the step-size, satisfying the Robbins  \n134 Monro constraints, $\\begin{array} { r } { \\gamma _ { t } \\in [ 0 , 1 ] , \\sum _ { t \\geq 1 } \\gamma _ { t } = \\infty , \\sum _ { t \\geq 1 } \\gamma _ { t } ^ { 2 } < \\infty , } \\end{array}$ and $\\nabla _ { \\theta }$ is the gradient w.r.t. $\\theta$ . In this   \n135 way, the computations made in $\\nabla _ { \\boldsymbol { \\theta } } \\widehat { \\mathcal { Q } }$ are accumulated via $\\theta _ { t }$ and reused over the iterations.   \n136 The parameters $\\eta _ { z }$ have a different form based on a specific case of $p _ { \\eta _ { z } } ( x | z )$ , whereas $\\pi _ { z }$ is a   \n137 permanent structure in (1). Therefore, without loss of generality, we split (6) into a generic part and a   \n138 fixed part as follows: ",
+        "bbox": [
+            140,
+            502,
+            826,
+            636
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            641,
+            828,
+            684
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1b6543f038daf2078a131f2fa387f7478babb5133579989565df178123b0c85.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\eta _ { k , t } = \\eta _ { k , t - 1 } + \\gamma _ { t } \\nabla _ { \\eta _ { k } } \\widehat { \\mathcal { Q } } _ { t - 1 } ( \\theta ) , } \\\\ & { \\nu _ { k , t } = \\nu _ { k , t - 1 } + \\gamma _ { t } \\nabla _ { \\nu _ { k } } \\widehat { \\mathcal { Q } } _ { t - 1 } ( \\theta ) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            688,
+            606,
+            732
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "139 where—to ensure that the probabilities, $( \\pi _ { k , t } ) _ { k = 1 } ^ { K }$ , satisfy the constraints (Section 2)—we transform   \n140 $\\nabla _ { \\pi _ { k } } \\widehat { \\mathcal { Q } }$ via $\\nu _ { k } = \\log \\pi _ { k }$ and optimize w.r.t. $\\nu _ { k }$ . Then, to obtain $( \\pi _ { k , t } ) _ { k = 1 } ^ { K }$ from $\\nu _ { t } : = ( \\nu _ { k , t } ) _ { k = 1 } ^ { K }$ , we   \n141 k b  use the softmax function, i.e. $\\pi _ { k , t } : = \\mathrm { s o f t m a x } ( \\pmb { \\nu } _ { t } ) _ { k } : = \\exp ( \\nu _ { k , t } ) / \\sum _ { l = 1 } ^ { K } \\exp ( \\nu _ { l , t } )$ . ",
+        "bbox": [
+            142,
+            734,
+            825,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Computing the gradients for all pairs of $( \\nu _ { k } , \\eta _ { k } ) _ { k = 1 } ^ { K }$ would be inefficient, especially since ${ \\bf z } _ { i , t }$ contains only a small number of unique values of Z for $M \\ll K$ . Consequently, we compute $\\dot { \\nabla } _ { \\eta _ { k } } \\widehat { \\mathcal { Q } }$ and $\\nabla _ { \\nu _ { k } } \\widehat { \\mathcal { Q } }$ only for $k \\in { \\mathrm { u n i q u e } } ( \\mathbf { z } _ { i , t } )$ . We summarize the proposed approach in Algorithm 1. ",
+        "bbox": [
+            160,
+            792,
+            825,
+            843
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.3 Proposal distribution ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            857,
+            361,
+            872
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "146 The choice of the proposal distribution has a significant impact on the speed of convergence and the computational cost of the proposed algorithm. Here, we discuss various possible choices of 147 $q \\big ( z _ { i } | \\bar { z } _ { i } \\big )$ . ",
+        "bbox": [
+            145,
+            882,
+            828,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Input: $\\theta _ { 0 }$ , $( \\mathbf { z } _ { i , 0 } ) _ { i = 1 } ^ { N }$ , $( \\mathbf { x } _ { i } ) _ { i = 1 } ^ { N }$   \nOutput: $( \\theta _ { t } ) _ { t = 1 } ^ { T }$ for $t \\in ( 1 , \\ldots , T )$ or until convergence do form the set $\\dot { I } = ( i _ { j } ) _ { j = 1 } ^ { B }$ by sampling (without replacement) $B$ indices $i \\sim ( 1 , \\dots , N )$ for $i \\in I$ do set $\\bar { z } _ { i }$ as the last element of $\\mathbf { z } _ { i , t - 1 }$ for $j \\in ( 1 , \\ldots , M )$ do sample $z _ { i } \\sim q ( z _ { i } | \\bar { z } _ { i } )$ sample $u \\sim \\mathrm { U n i f o r m } ( 0 , 1 )$ compute $\\alpha ( \\bar { z } _ { i } , z _ { i } )$ in (7) if $u < \\alpha \\big ( \\bar { z } _ { i } , z _ { i } \\big )$ then set $z _ { i , t } ^ { j } = z _ { i }$ and $\\bar { z } _ { i } = z _ { i }$ else set $z _ { i , t } ^ { j } = \\bar { z } _ { i }$ end if end for set $\\mathbf { z } _ { i , t } = ( z _ { i , t } ^ { 1 } , \\dots , z _ { i , t } ^ { M } )$ end for compute (8) compute (9) for $k \\in { \\mathrm { u n i q u e } } ( \\mathbf { z } _ { i , t } )$ compute $\\pi _ { k , t } : = \\mathrm { s o f t m a x } ( \\pmb { \\nu } _ { t } ) _ { k }$ for $k \\in { \\mathord { \\mathbb { Z } } }$ end for ",
+        "bbox": [
+            173,
+            108,
+            787,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "148 Optimal proposal $( O )$ . The optimal proposal distribution is $q ( z _ { i } | \\bar { z } _ { i } ) : = q ( z _ { i } ) : = p _ { \\theta } ( z _ { i } | x _ { i } )$ . This   \n149 ensures that the acceptance rate (7) is always $\\alpha ( \\bar { z } _ { i } , z _ { i } ) = 1$ . However, the need to perform $K$   \n150 expensive evaluations of $p _ { \\theta } ( z _ { i } , x _ { i } )$ before sampling from $p _ { \\theta } ( z _ { i } | x _ { i } )$ is the reason we resorted to   \n151 the MH sampler in the first place. We consider this case only to set the upper limit on admissible   \n152 computational cost and to study the impact of sub-optimal proposal distribtions.   \n153 Uniform proposal $( U )$ . The uniform distribution on the discrete interval from 1 to $K$ , i.e. $q ( z _ { i } | \\bar { z } _ { i } ) : =$   \n154 $q ( z _ { i } ) : = \\mathrm { U n i f o r m } ( 1 , K )$ , is the simplest and computationally cheapest variant of the proposal   \n155 distribution. However, due to poor mixing properties, the algorithm may converge slowly for high $K$ .   \n156 Tabular proposal with forgetting $( T F )$ . The key requirement to design a proposal distribution is to   \n157 restrict its computational complexity somewhere between that of the $\\mathrm { U }$ and $\\mathrm { o }$ proposals. One way to   \n158 satisfy this constraint is to use the Markov chain, $( z _ { i , t } ) _ { t = 1 } ^ { T }$ , to learn a transition kernel, $p ( z _ { i } | \\bar { z } _ { i } )$ , see,   \n159 e.g. [3]. Unfortunately, this would require us to store a table with $K ^ { 2 }$ entries for each $i \\in ( 1 , \\ldots , N )$ ,   \n160 161 which is very demanding evethe Markov chain and define: $q ( z _ { i } | \\bar { z } _ { i } ) : = q _ { \\alpha _ { i } } ( z _ { i } ) : = \\mathcal { C } ( \\alpha _ { i } )$ $K$ $N$ herefore, where $\\mathcal { C } ( \\pmb { \\alpha } _ { i } ) \\propto \\Pi _ { k = 1 } ^ { K } \\alpha _ { k , i } ^ { \\bar { 1 ( } z _ { i } = k ) }$ nce inis the   \n162 categorical distribution with the weights $\\pmb { \\alpha } _ { i } : = ( \\alpha _ { 1 , i } , \\dots , \\alpha _ { K , i } )$ . For $\\mathcal { L } ( \\pmb { \\alpha } _ { i } ) : = \\Sigma _ { \\tau = 1 } ^ { t } \\log q _ { \\pmb { \\alpha } _ { i } } ( z _ { i , \\tau } )$   \n163 we obtain an estimate of $\\alpha _ { i }$ at iteration $t$ as follows: $\\begin{array} { r } { \\alpha _ { i , t } : = \\mathrm { \\ a r g m a x } _ { \\alpha _ { i } } \\mathcal L ( \\alpha _ { i } ) \\ = \\ \\frac { n _ { i , t } } { t } } \\end{array}$ t , with   \n164 $n _ { i , t } = \\Sigma _ { \\tau = 1 } ^ { t } \\mathbf { e } _ { z _ { i , t } }$ , where $\\mathbf { e } _ { k }$ is the standard basis vector (a one-hot vector) with one at $k$ th position   \n165 and zeros otherwise. This can be further rewritten into a recursive form: $n _ { i , t } = n _ { i , t - 1 } + \\mathbf { e } _ { z _ { i , t } }$ or,   \n166 using the Robbins-Monro step-size, $n _ { i , t } = ( { \\bf 1 } - { \\bf e } _ { z _ { i , t } } \\gamma _ { t } ) \\odot n _ { i , t - 1 } + \\gamma _ { t } { \\bf e } _ { z _ { i , t } }$ , where 1 is the vector of   \n167 ones, and $\\odot$ is the Hadamard product. We refer to this case simply as “table with forgetting” (TF)   \n168 due to that it represents $N \\times K$ table in the memory and $\\gamma _ { t }$ is a forgetting factor. ",
+        "bbox": [
+            140,
+            449,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            525,
+            826,
+            568
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            573,
+            826,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "169 5 Related work ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            782,
+            316,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Stochastic approximation expectation-maximization. The application of SA to prevent the evaluation   \n1 of all $K$ components in mixture models has been overlooked for a long time. The reason is that the   \n72 original motivation to combine the EM algorithm with SA is to address the analytical intractability   \n73 of the expected value under $p _ { \\theta } ( z | x )$ in (4), which is, however, almost always tractable for mixture   \n74 models. The intractability issue is addressed by either the Monte Carlo SAEM (MCSAEM) [12]   \n75 or the Markov chain Monte Carlo SAEM (MCMCSAEM) [31]. Applying the former approach to   \n76 mixture models would be inefficient, since it evaluates $K$ joint distributions, $p _ { \\theta } ( z , x )$ , before drawing   \n177 $M$ samples from $p _ { \\theta } ( z | x )$ . Therefore, this method reduces only the computational cost of updating the   \n178 sufficient statistics. This is addressed by the latter approach, where $M < K$ samples from a proposal   \n179 distribution, $q ( z | x )$ , is used to calculate $p _ { \\theta } ( z , x )$ and also the sufficient statistics. However, all these   \n180 methods process all data at every iteration, providing only a limited advantage over the conventional   \n181 EM algorithm. Minibatch versions of these techniques have recently been proposed [27, 32, 1].   \n182 All the above methods commonly assume $p _ { \\theta } ( z , x )$ belonging to the exponential family. This provides   \n183 a convenient, but limiting, property which allows (6) to be computed under a closed-form solution.   \n184 The main contribution of our work is to release this restrictive assumption by admitting that $p _ { \\theta } ( z , x )$   \n185 (and thus $\\mathcal { Q }$ ) is given by possibly complex and intractable transformations.   \n186 Sparse and truncated variational techniques. There is only a small body of methods explicitly   \n187 reducing the number of evaluated components. Their common aspect is that they follow from the   \n188 variational framework, where the exact posterior, $p _ { \\theta } ( z | x )$ , is approximated by a variational posterior,   \n189 $q ( z | x )$ . This sparse, approximate, posterior is defined over a lower number of components, $M \\ll K$ ,   \n190 such that only the important components are selected, relying on relaxation of the hard EM algorithm   \n191 from taking a single $M = 1$ assignment [26] to taking multiple $M \\ll K$ assignments. The sparse   \n192 SAEM (SSAEM) algorithm [24] selects the components by a quick partial sorting of the posterior   \n193 probabilities, $p _ { \\theta } ( z | x )$ . Again, this requires $K$ evaluations of $p _ { \\theta } ( z , x )$ before the sorting, thus only   \n194 reducing the amount of updated statistics. Similarly, the truncated SAEM (TSAEM) algorithm [18]   \n195 selects $M < K$ cluster-to-cluster and $\\bar { M } < K$ cluster-to-datapoint minimal Euclidean distances,   \n196 preventing the problem in the SSAEM algorithm. However, all these distances are evaluated for all   \n197 components in a pairwise manner, leading to $K ^ { 2 }$ -computational complexity, which makes the saving   \n198 dubious. Similarly as before, these methods assume $p _ { \\theta } ( z , x )$ to belong to the exponential family. ",
+        "bbox": [
+            155,
+            814,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c516376ee7ecf27c7edaec6674fb19224d829bc10798ac37d421adee064aa0e.jpg",
+        "image_caption": [
+            "Figure 1: The training log-likelihood, $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t } )$ , versus the computational time (in seconds). Here, on the $\\mathbf { X }$ -axis, the computational time at a current iteration, $t$ , is obtained by accumulating the time from the previous iterations. corresponds to $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t _ { 9 5 } } )$ , where $t _ { 9 5 }$ is the iteration of reaching $9 5 \\%$ of max $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t } )$ . The projection of $^ { \\circ }$ on the $\\mathbf { X }$ -axis gives the time to reach $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t _ { 9 5 } } )$ . This experiment was performed with the following settings: $( D , \\bar { K } , N , \\omega , B , M , T ) = ( 1 0 , 1 0 0 , 1 0 k , 0 . 1 , \\bar { 2 } 0 0 , 2 , 2 0 k )$ , see Section 6.1 for details. The results are averaged over five repetitions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            285,
+            92,
+            699,
+            236
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            356,
+            825,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            433,
+            825,
+            488
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            494,
+            826,
+            674
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "199 We summarize the distinguishing features of the above discussed methods in Table 1. ",
+        "bbox": [
+            151,
+            680,
+            728,
+            695
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            714,
+            312,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the key features of our algorithm—its low computational complexity, competitive learning performance, and generality—we use it below to train: (i) GMMs on synthetic datasets, and (ii) SPTNs [47] and (iii) mixtures of real NVP flows [48] on real datasets. All experiments have been performed on a Slurm cluster equipped with Intel Xeon Scalable Gold 6146 with 384GB of RAM. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            800
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 Gaussian mixture models ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            816,
+            388,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Consider the special case of a data-generating distribution given by (1), with the components taking the form of the multivariate Gaussian distribution, $p _ { \\eta _ { z } } ( x | z ) = \\mathcal { N } ( x ; \\mu _ { z } , \\Sigma _ { z } )$ , where $\\mu _ { z }$ is the mean value and $\\Sigma _ { z }$ is the covariance matrix. The difficulty of learning GMMs heavily depends on the degree of interaction among all mixture components, hence having the ability to generate synthetic datasets with arbitrary overlap characteristics between all pairs of components is crucial for systematic ",
+        "bbox": [
+            173,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ced572977ae404a4e785379dc4987ce758b6f6930ca4d73adbe35955ed678b7.jpg",
+        "image_caption": [
+            "Figure 2: The absolute error, $\\mathrm { A E } = | \\mathcal { L } ( \\theta _ { t _ { 9 5 } } ) - \\mathcal { L } ( \\theta ) |$ , versus the computational time (in seconds). All experiments use the following settings: $( D , K , \\dot { N } , \\omega , B , M , T ) = \\bar { ( } 1 0 , 1 0 0 , 1 0 k , 0 . 1 , 2 0 0 , 2 , 2 0 k )$ , where the number of components, $K$ , (left), the batchsize, $B$ , (middle) and the number of samples, $M$ , (right) change for different values denoted by $( + , \\sqsupset , \\circ , \\pmb { \\triangle } )$ . At each of these points (marks), we perform an experiment as illustrated in Figure 1, find $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t _ { 9 5 } } )$ to compute the AE, and record the time corresponding to $t _ { 9 5 }$ . The results are averaged over five repetitions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            89,
+            805,
+            250
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "211 evaluation of performance of learning algorithms [43]. Traditional techniques usually define overlap   \n212 (or separation) of components only in terms of their mean vectors and maximum eigenvalues of the   \n213 covariance matrices, not accounting for their rotation and mixing weights (see [36] for a detailed   \n214 treatment of the problem). We therefore use a more objective measure of the clustering complexity   \n215 defined by the total probability of misclassification [41], which allows to generate data with a   \n216 user-defined degree of maximum pairwise overlap, $\\omega$ .   \n217 Experiment settings: We generate the parameters of (1), and the corresponding dataset, uniquely for a   \n218 given quadruple $( D , K , N , \\omega )$ . Therefore, the parameters of the generative model are known and we   \n219 can measure and display the convergence of the training log-likelihood, $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t } )$ , compared to the exact   \n220 log-likelihood, $\\mathcal { L } ( \\boldsymbol { \\theta } ) \\dot { }$ , for $t = ( 1 , \\ldots , T )$ . We are further interested in the absolute error between the   \n221 training log-likelihood at the iteration of reaching $9 5 \\%$ of its maximum value, $t _ { 9 5 }$ , and the exact   \n222 log-likelihood, i.e. $\\mathrm { A E } = | \\mathcal { L } ( \\theta _ { t _ { 9 5 } } ) - \\mathcal { L } ( \\theta ) |$ .   \n23 We also measure the computational time until reaching $t _ { 9 5 }$ . We have used $9 5 \\%$ of the maximum   \n24 value instead of the maximum value to prevent cases, where the model oscillate around target value,   \n25 making the estimate of convergence time very noisy (for example MCSAEM in Figure 1).   \n226 Algorithms: The GMMs belong to the exponential family of probability distributions. This allows us   \n227 to find a closed-form, recursive, solution of (6), relying on a Robbins-Monro type of the step-size   \n228 sequence, $( \\gamma _ { t } ) _ { t = 1 } ^ { T }$ , [7, 44]. In this setting, we compare our MHSAEM algorithm with a number of   \n229 related methods in Table 1. Note we use the acronyms U and TF to specify the proposal distribution of   \n230 the MHSAEM algorithm (Section 4.3). However, we do not use the O-proposal, since the MHSAEM  \n231 O algorithm is equivalent to the MCSAEM algorithm. All the SA-variants in Table 1 use a minibatch   \n232 of size $B$ . The key quantity to reduce the number of evaluated components and/or sufficient statistics   \n233 in the SSAEM, TSAEM, MCSAEM and MHSAEM algorithms is collectively denoted by $M$ (Section   \n234 5). Note that we always keep $M = \\bar { M }$ in the TSAEM algorithm (see Figure 1 and 2 for concrete   \n235 numbers). We use the step-size given by $\\gamma _ { t } = 1$ for $t = 1 , \\ldots , 5 0$ and $\\gamma _ { t } = 0 . 0 5$ otherwise. In   \n236 this section, to counteract the issue of attaining poor local optima, we equip all algorithms with the   \n237 anti-annealing schedule $( \\beta _ { t } ) _ { t = 1 } ^ { T }$ , starting with $\\beta _ { 1 } = 0 . 1$ , reaching $\\beta _ { 2 / 3 T } = 1 . 2$ , and decreasing back   \n238 to $\\beta _ { T } = 1 . 0$ , see [43] for details. The initial estimates of: (i) $\\mu _ { k }$ are uniformly drawn from the unit   \n239 hyper-cube, (ii) $\\Sigma _ { k }$ are fixed to unit diagonal matrix, and (iii) $\\pi _ { k }$ are uniformly drawn from the unit   \n240 interval (followed by normalization).   \n241 Results: Figure 1 shows that the EM [13] and SAEM [44] algorithms take the longest time to   \n242 converge, attaining a poor local optima. On the other hand, the MCSAEM [1] and MHSAEM (U   \n243 and TF) algorithms achieve $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t _ { 9 5 } } )$ closest to the likelihood $\\mathcal { L } ( \\boldsymbol { \\theta } )$ of the true model. Moreover, both   \n244 MHSAEM algorithms reach this value in the shortest time compared to all the other methods. The   \n245 SSAEM [24] and TSAEM [18] algorithms are comparable in terms of the computational time, but   \n246 they both provide the lowest $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t _ { 9 5 } } )$ . In Figure 2, we investigate sensitivity of fitting the model to   \n47 increasing values of $K$ , $B$ and $M$ by measuring the time and the likelihood again. In all the cases,   \n48 the proposed MHSAEM algorithms achieve the lowest AE in the shortest time. ",
+        "bbox": [
+            140,
+            387,
+            825,
+            470
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            477,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            156,
+            566,
+            826,
+            608
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            614,
+            826,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            828,
+            825,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "SSAEM and TSAEM algorithms failed to converge for $M > 2$ and for $K > 5 0$ respectively. We believe this is caused by selecting only $M$ maximal probabilities in the SSAEM (or distances in the TSAEM) algorithm (Section 5), which prevents certain, but not a negligible number of, components from being updated, thus providing only a crude approximation of $\\bar { p } _ { \\theta } \\bar { ( } z | x )$ . The results then suffer from substantial variational gap to the exact log-likelihood (Figure 1). On the contrary, MH sampler provides samples which consistently approximate $p _ { \\theta } ( z | x )$ despite evaluating much lower number of components in each step. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.2 Sum-product transform networks ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            239,
+            446,
+            253
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The sum product networks (SPNs) are a deep learning extension of finite mixture models. They can be interpreted as a mixture of trees [60], where each tree corresponds to a component. Therefore, they can be cast into the form of (1), but the number of components grows exponentially with their depth. In this section, we use recently proposed SPTNs which introduce additional transformation nodes to provide better expressiveness than the SPNs (SPTNs effectively generalize SPNs and flow models into one large family of models). ",
+        "bbox": [
+            173,
+            265,
+            825,
+            348
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Experimental settings: We use 19 real datasets from the UCI database [16, 37, 35, 54], preprocessed in the same way as in [46]. For each experiment, we randomly split the data into $64 \\%$ , $16 \\%$ and $20 \\%$ for training, validation and testing, respectively. We calculate the average log-likelihood on the test set and measure again the time to reach $9 5 \\%$ of the maximal training log-likelihood, $\\mathcal { L } ( \\boldsymbol { \\theta } _ { t _ { 9 5 } } )$ . ",
+        "bbox": [
+            171,
+            354,
+            825,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To evaluate various (possibly shallow and/or deep) architectures of SPTNs, we fit each dataset with all the following combinations of hyper-parameters1: $s \\in ( 8 , 3 2 , 1 2 8 )$ , $b \\in ( 2 , 4 , 6 , 8 )$ , $l \\in ( 2 , 3 , 4 )$ , where $s$ is the number of children of each sum node, $b$ is the number of partitions of each product node, and $l$ is the number of layers (one layer contains sum and product nodes). The number of components of the SPTN, after its conversion into (1), is given as follows: $K = s ^ { l }$ . Note that the maximum number of components for the investigated parameters of the SPTN is 268,435,456. To reduce the space of possible architectures, we restrict ourselves only to (i) the leaf nodes given by $\\mathcal { N } ( 0 , \\bf { I } )$ ; (ii) affine transformations fixed to the singular value decomposition, choosing the the Givens parameterization for the unitary matrices [47]; and (iii) no sharing of any type of nodes [47]. ",
+        "bbox": [
+            161,
+            416,
+            825,
+            541
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "276 Algorithms: We evaluate only on the MHSAEM-U algorithm—due to its favourable computational   \n277 complexity and simplicity—and compare it with the stochastic gradient-descent (SGD) algorithm,   \n278 which is routinely used to train SP(T)Ns [45, 47]. In this case, SGD in each iteration performs   \n279 computations over all subtrees of the network, whereas the MHSAEM-U algorithm computes with   \n280 only $M = 1$ subtrees, thus we should observe speed-up of the computations. In our implementation,   \n281 both these methods perform optimization of their respective objective functions—the log-likelihood   \n282 (2) for SGD and the EM objective (8) for MHSAEM-U—via the use of the automatic differentiation   \n283 and the ADAM optimizer [29], using $B = 1 0 0$ and $T = 2 0 0 0 0$ . ",
+        "bbox": [
+            142,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results: Since each dataset might benefit from a different architecture, Table 6.2 shows the test log-likelihood of the architectures selected according to the best likelihood measured on the validation set and the corresponding speed-up. The test log-likelihoods reveal that the MHSAEM-U algorithm outperforms the SGD algorithm on 10 out of 19 datasets, which was not originally the goal, but the added stochasticity helps to escape poor local minima. The speed-up demonstrates lower computational complexity of the MHSAEM-U algorithm on 17 out of 19 datasets, which was the main goal. The magic-telescope and wine datasets show approximately $1 0 2 \\times$ and $7 5 \\times$ speed-up, respectively, while on very small datasets (pima-indians and iris), the SGD is faster due to effective implementation. In the supplementary material, we present Table 3, exhibiting the same trends on a fixed architecture. ",
+        "bbox": [
+            171,
+            665,
+            825,
+            803
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6.3 Mixtures of real NVP flows ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            819,
+            400,
+            834
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We consider another class of mixture models (1), where each component $p _ { \\eta _ { z } } ( x | z )$ is transformed by the flow model—real NVP [15]. These transformations are parameterized via deep neural networks, allowing for flexible adjustment of the learning capacity of each component. ",
+        "bbox": [
+            176,
+            845,
+            825,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/82dc83ba06aea51dfe211f3df1e7f4eb07c99ebac951998df4d56e6c0d99003a.jpg",
+        "table_caption": [
+            "Table 2: The speed-up and test log-likelihood, $\\mathcal { L } ^ { \\mathrm { t e s t } }$ , for the SGD and MHSAEM-U algorithms. The test log-likelihood (higher is better) is computed for the best model, with the corresponding $K$ , which is selected based on the validation log-likelihood. The speed-up is computed as the ratio of MHSAEM-U to SGD, i.e. their time to reach $9 5 \\%$ of the training log-likelihood. The results are averaged over five repetitions. Then, the higher test log-likelihood is highlighted with bold blue, and and no speed-up is highlighted with red. The average rank is computed as the standard competition (“1224”) ranking [14] on each dataset (lower is better). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\"></td><td colspan=\"5\">Sum-product transformnetworks</td><td colspan=\"5\">Mixtures of real NVP flows SGD</td></tr><tr><td rowspan=\"2\"></td><td colspan=\"2\">SGD</td><td colspan=\"2\">MHSAEM-U</td><td colspan=\"2\"></td><td colspan=\"2\"></td><td colspan=\"2\">MHSAEM-U</td></tr><tr><td>speed-up</td><td>Ltest</td><td>K</td><td>Ltest</td><td>K</td><td>speed-up</td><td>Ltest</td><td>K 32</td><td>Ltest</td><td>K</td></tr><tr><td>breast-cancer-wisconsin</td><td>4.66</td><td>-4.66</td><td>64</td><td>1.43</td><td>1024</td><td>0.63</td><td>-99.85</td><td></td><td>-39.31</td><td></td><td>128</td></tr><tr><td>cardiotocography</td><td>10.55</td><td>59.52</td><td>512</td><td>31.04</td><td>1024</td><td></td><td>9.85</td><td>54.34</td><td>32</td><td>56.08</td><td>128</td></tr><tr><td>magic-telescope</td><td>102.53</td><td>-3.65</td><td>512</td><td>-5.03</td><td>1024</td><td></td><td>3.74</td><td>-3.97</td><td>8</td><td>-4.22</td><td>8</td></tr><tr><td>pendigits</td><td>4.89</td><td>0.88</td><td>1024</td><td>-4.86</td><td>16384</td><td></td><td>4.17</td><td>1.46</td><td>8</td><td>0.48</td><td>8</td></tr><tr><td>pima-indians</td><td>0.37</td><td>-8.54</td><td>64</td><td>-7.62</td><td></td><td>64</td><td>1.35</td><td>-20.09</td><td>128</td><td>-16.33</td><td>128</td></tr><tr><td>wall-following-robot</td><td>3.43</td><td>1.84</td><td>1024</td><td>-11.3</td><td>16384</td><td></td><td>22.21</td><td>-14.26</td><td>128</td><td>-17.56</td><td>128</td></tr><tr><td>waveform-1</td><td>4.35</td><td>-26.14</td><td>64</td><td>-23.91</td><td>1024</td><td></td><td>3.72</td><td>-34.12</td><td>8</td><td>-33.42</td><td>8</td></tr><tr><td>waveform-2</td><td>4.82</td><td>-26.21</td><td>64</td><td>-23.91</td><td></td><td>1024</td><td>4.12</td><td>-34.15</td><td>8</td><td>-33.64</td><td>8</td></tr><tr><td>yeast</td><td>20.57</td><td>10.26</td><td>512</td><td>5.18</td><td>1024</td><td></td><td>14.49</td><td>6.61</td><td>128</td><td>9.59</td><td>128</td></tr><tr><td>ecoli</td><td>1.86</td><td>-5.5</td><td>64</td><td>-0.22</td><td>1024</td><td></td><td>2.15</td><td>-11.37</td><td>128</td><td>-10.64</td><td>128</td></tr><tr><td>ionosphere</td><td>1.88</td><td>-20.27</td><td>64</td><td>-5.93</td><td></td><td>512</td><td>2.74</td><td>-87.01</td><td>128</td><td>-42.75</td><td>128</td></tr><tr><td>iris</td><td>0.23</td><td>-10.65</td><td>64</td><td>-1.49</td><td>16384</td><td></td><td>3.28</td><td>-16.34</td><td>128</td><td>-9.21</td><td>32</td></tr><tr><td>page-blocks</td><td>12.18</td><td>12.21</td><td>512</td><td>6.84</td><td>1024</td><td></td><td>44.95</td><td>17.13</td><td>128</td><td>17.94</td><td>32</td></tr><tr><td>parkinsons</td><td>1.46</td><td>-21.85</td><td>64</td><td>0.5</td><td></td><td>512</td><td>3.09</td><td>-566.58</td><td>128</td><td>-33.31</td><td>32</td></tr><tr><td>sonar</td><td>2.96</td><td>-95.39</td><td>512</td><td>-69.29</td><td></td><td>64</td><td>2.52</td><td>-622.2</td><td>128</td><td>-88.81</td><td>128</td></tr><tr><td>statlog-segment</td><td>1.44</td><td>47.35</td><td>512</td><td>26.53</td><td>16384</td><td></td><td>38.49</td><td>35.84</td><td>128</td><td>42.04</td><td>32</td></tr><tr><td>statlog-vehicle</td><td>2.97</td><td>-4.25</td><td>64</td><td>-5.45</td><td>1024</td><td></td><td>6.78</td><td>-31.34</td><td>32</td><td>-26.43</td><td>128</td></tr><tr><td>wine rank</td><td>75.42</td><td>-25.99</td><td>1024</td><td>-13.27</td><td></td><td>1024</td><td>2.05</td><td>-171.58</td><td>128</td><td>-25.57</td><td>128</td></tr><tr><td></td><td></td><td>1.56</td><td></td><td>1.44</td><td></td><td></td><td></td><td>1.83</td><td></td><td>1.17</td><td></td></tr></table>",
+        "bbox": [
+            186,
+            194,
+            813,
+            422
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "298 Experimental settings: We use the same experimental settings and evaluation metrics as in Section   \n299 6.2. We apply the mixture model on all datasets, changing the number of components as follows:   \n300 $K \\in ( 8 , 3 2 , 1 2 8 )$ . Each real NVP-based component in the mixture model has (i) the translation   \n301 function parameterized via multi-layer perceptron with a single hidden layer of dimension 10, using   \n302 the rectified linear activation function; and (ii) the scale function parameterized via the same network   \n303 except with the hyperbolic tangent activation function. We do not use the batch normalization [15] and   \n304 we stack two layers of the translation-scale transformation (we have used implementation from [20]). ",
+        "bbox": [
+            147,
+            455,
+            825,
+            553
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Algorithms: The algorithms and their settings are the same as those in Section 6.2. ",
+        "bbox": [
+            161,
+            559,
+            710,
+            574
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "306 Results: The experimental results are presented in right part of Table 6.2. They are similar to those   \n307 obtained in the previous section. In terms of the test log-likelihood, the MHSAEM-U algorithm   \n308 outperforms the SGD algorithm on all but three datasets, and it provides a substantial speed-up on all   \n309 datasets except one. The test likelihood of models with the real NVP flows is most of the time worse   \n310 than that of SPTNs with the affine transformations. As explained in the supplementary, this is due to   \n311 the overfitting, which has been observed in [47]. ",
+        "bbox": [
+            140,
+            580,
+            825,
+            664
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "312 7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            689,
+            299,
+            707
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "313 This paper has presented a method to decrease computational complexity of fitting mixture models,   \n314 including their generalizations, such as sum-product-(transform) networks and mixtures of flow   \n315 models. The speed-up is achieved by evaluating and updating only a single component (per iteration),   \n316 where the Metropolis-Hasting algorithm ensures sampling of components from a proper posterior. An   \n317 experimental comparison on all three classes of models mentioned above confirmed the theoretical   \n318 expectations. The method significantly speeds-up the fitting time and, importantly, without sacrificing   \n319 the quality of the fit. In fact, the likelihood was better than that of the models fitted by the EM   \n320 algorithm or the SGD algorithm in more than $50 \\%$ of cases. We attribute this to higher stochasticity,   \n321 which helps to escape from poor local minima.   \n322 In the experiments, the proposed method has used a uniform proposal distribution in the MH sampler.   \n323 Despite outperforming the alternative methods, we conjecture that this limits the speed of convergence.   \n324 Therefore, we believe that there is still a room for improvement in the implementation. We plan to   \n325 address these issues in future work. ",
+        "bbox": [
+            140,
+            724,
+            825,
+            849
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The presented method decreases the computational complexity of fitting large (and deep) mixture models, which leads to five to hundred time speed-up depending on a size of the problem (although negative exceptions occurs). We believe this line of research, which we want to continue, to have important benefits. First, it is directly related to decrease in energy consumption and in production of CO2 (we expect similar rates as the speedup). Second, it has a positive effect on financial aspects of deploying (and experimenting with) mixture models. Third, it decreases the hardware requirements, as in all experiments presented above the model was fitted on a single-core. ",
+        "bbox": [
+            173,
+            121,
+            826,
+            218
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            239,
+            266,
+            255
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] S. Allassonnière and J. Chevallier. A new class of stochastic EM algorithms: Escaping local maxima and handling intractable sampling. Computational Statistics & Data Analysis, 159:107159, 2021.   \n[2] S. Ayesha, M. K. Hanif, and R. Talib. Overview and comparative study of dimensionality reduction techniques for high dimensional data. Information Fusion, 59:44–58, 2020.   \n[3] D. S. Bai. Efficient estimation of transition probabilities in a Markov chain. The Annals of Statistics, pages 1305–1317, 1975.   \n[4] D. M. Blei, A. Kucukelbir, and J. D. McAuliffe. Variational inference: A review for statisticians. Journal of the American statistical Association, 112(518):859–877, 2017.   \n[5] J. Blömer and K. Bujna. Adaptive seeding for Gaussian mixture models. In Pacific-asia conference on knowledge discovery and data mining, pages 296–308. Springer, 2016.   \n[6] T. Campbell and B. Beronov. Sparse variational inference: Bayesian coresets from scratch. arXiv preprint arXiv:1906.03329, 2019.   \n[7] O. Cappé and E. Moulines. On-line expectation–maximization algorithm for latent data models. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 71(3):593–613, 2009.   \n[8] J. Chen, J. Zhu, Y. Teh, and T. Zhang. Stochastic expectation maximization with variance reduction. Advances in Neural Information Processing Systems, page 7967, 2018.   \n[9] N. Chopin. A sequential particle filter method for static models. Biometrika, 89(3):539–552, 2002.   \n[10] G. Compiani and Y. Kitamura. Using mixtures in econometric models: A brief review and some new results. The Econometrics Journal, 19(3):C95–C127, 2016.   \n[11] S. Dasgupta. Learning mixtures of Gaussians. In 40th Annual Symposium on Foundations of Computer Science (Cat. No. 99CB37039), pages 634–644. IEEE, 1999.   \n[12] B. Delyon, M. Lavielle, E. Moulines, et al. Convergence of a stochastic approximation version of the EM algorithm. The Annals of Statistics, 27(1):94–128, 1999.   \n[13] A. P. Dempster, N. M. Laird, and D. B. Rubin. Maximum likelihood from incomplete data via the EM algorithm. Journal of the Royal Statistical Society: Series B (Methodological), 39(1):1–22, 1977.   \n[14] J. Demšar. Statistical comparisons of classifiers over multiple data sets. The Journal of Machine Learning Research, 7:1–30, 2006.   \n[15] L. Dinh, J. Sohl-Dickstein, and S. Bengio. Density estimation using real NVP. In 5th International Conference on Learning Representations, ICLR 2017, 2017.   \n[16] D. Dua and C. Graff. UCI machine learning repository, 2017. ",
+        "bbox": [
+            178,
+            260,
+            828,
+            917
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[17] D. Feldman, M. Faulkner, and A. Krause. Scalable training of mixture models via coresets. In Proceedings of the 24th International Conference on Neural Information Processing Systems, pages 2142–2150, 2011. 372 [18] D. Forster and J. Lücke. Can clustering scale sublinearly with its clusters? A variational EM acceleration of GMMs and k-means. In International Conference on Artificial Intelligence and Statistics, pages 124–132. PMLR, 2018. [19] G. Fort, E. Moulines, et al. Convergence of the Monte Carlo expectation maximization for curved exponential families. Annals of Statistics, 31(4):1220–1259, 2003. [20] J. Franc˚u. Continuousflows.jl. https://github.com/janfrancu/ContinuousFlows.jl, 2020. [21] K. Greff, S. van Steenkiste, and J. Schmidhuber. Neural expectation maximization. In Proceedings of the 31st International Conference on Neural Information Processing Systems, pages 6694–6704, 2017. [22] R. Gribonval, A. Chatalic, N. Keriven, V. Schellekens, L. Jacques, and P. Schniter. Sketching datasets for large-scale learning (long version). arXiv preprint arXiv:2008.01839, 2020. [23] M. D. Hoffman, D. M. Blei, C. Wang, and J. Paisley. Stochastic variational inference. Journal of Machine Learning Research, 14(5), 2013. [24] M. C. Hughes and E. B. Sudderth. Fast learning of clusters and topics via sparse posteriors. arXiv preprint arXiv:1609.07521, 2016. [25] K. Humphreys and D. Titterington. Approximate Bayesian inference for simple mixtures. In COMPSTAT, pages 331–336. Springer, 2000. [26] B.-H. Juang and L. R. Rabiner. The segmental K-means algorithm for estimating parameters of hidden Markov models. IEEE Transactions on acoustics, speech, and signal Processing, 38(9):1639–1641, 1990. [27] B. Karimi, M. Lavielle, and É. Moulines. On the convergence properties of the mini-batch EM and MCEM algorithms, 2019. [28] N. Keriven, A. Bourrier, R. Gribonval, and P. Pérez. Sketching for large-scale learning of mixture models. Information and Inference: A Journal of the IMA, 7(3):447–508, 2018. [29] D. P. Kingma and J. Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. [30] A. Kucukelbir, D. Tran, R. Ranganath, A. Gelman, and D. M. Blei. Automatic differentiation variational inference. The Journal of Machine Learning Research, 18(1):430–474, 2017. [31] E. Kuhn and M. Lavielle. Coupling a stochastic approximation version of EM with an MCMC procedure. ESAIM: Probability and Statistics, 8:115–131, 2004. [32] E. Kuhn, C. Matias, and T. Rebafka. Properties of the stochastic approximation EM algorithm with mini-batch sampling. Statistics and Computing, 30(6):1725–1739, 2020. [33] A. Lagrange, M. Fauvel, and M. Grizonnet. Large-scale feature selection with Gaussian mixture models for the classification of high dimensional remote sensing images. IEEE Transactions on Computational Imaging, 3(2):230–242, 2017. [34] M. Lavine and M. West. A Bayesian method for classification and discrimination. Canadian Journal of Statistics, 20(4):451–461, 1992. [35] M. Little, P. McSharry, S. Roberts, D. Costello, and I. Moroz. Exploiting nonlinear recurrence and fractal scaling properties for voice disorder detection. Nature Precedings, pages 1–1, 2007. [36] R. Maitra and V. Melnykov. Simulating data to study performance of finite mixture modeling and clustering algorithms. Journal of Computational and Graphical Statistics, 19(2):354–376, 2010. ",
+        "bbox": [
+            145,
+            93,
+            828,
+            920
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "15 [37] O. L. Mangasarian and W. H. Wolberg. Cancer diagnosis via linear programming. Technical report, University of Wisconsin-Madison Department of Computer Sciences, 1990.   \n17 [38] J.-M. Marin, K. Mengersen, and C. P. Robert. Bayesian modelling and inference on mixtures of distributions. Handbook of statistics, 25:459–507, 2005.   \n19 [39] C. A. McGrory, D. C. Ahfock, J. A. Horsley, and C. L. Alston. Weighted Gibbs sampling for mixture modelling of massive datasets via coresets. Stat, 3(1):291–299, 2014. [40] G. J. McLachlan, S. X. Lee, and S. I. Rathnayake. Finite mixture models. Annual review of statistics and its application, 6:355–378, 2019.   \n423 [41] V. Melnykov, W.-C. Chen, and R. Maitra. MixSim: An R package for simulating data to study performance of clustering algorithms. Journal of Statistical Software, 51(12):1, 2012.   \n25 [42] T. Monnier, T. Groueix, and M. Aubry. Deep transformation-invariant clustering. In Conference on Neural Information Processing Systems (NeurIPS 2020), 2020. [43] I. Naim and D. Gildea. Convergence of the EM algorithm for Gaussian mixtures with unbalanced mixing coefficients. In Proceedings of the 29th International Coference on International Conference on Machine Learning, pages 1427–1431, 2012. [44] H. D. Nguyen, F. Forbes, and G. J. McLachlan. Mini-batch learning of exponential family finite mixture models. Statistics and Computing, pages 1–18, 2020. [45] R. Peharz, A. Vergari, K. Stelzner, A. Molina, X. Shao, M. Trapp, K. Kersting, and Z. Ghahramani. Random sum-product networks: A simple and effective approach to probabilistic deep learning. In Uncertainty in Artificial Intelligence, pages 334–344. PMLR, 2020. [46] T. Pevný. Loda: Lightweight on-line detector of anomalies. Machine Learning, 102(2):275–304, 2016. [47] T. Pevný, V. Šmídl, M. Trapp, O. Polácek, and T. Oberhuber. Sum-product-transform networks: ˇ Exploiting symmetries using invertible transformations. arXiv preprint arXiv:2005.01297, 2020. [48] G. G. Pires and M. A. Figueiredo. Variational mixture of normalizing flows. arXiv preprint arXiv:2009.00585, 2020.   \n42 [49] A. Rau, C. Maugis-Rabusseau, M.-L. Martin-Magniette, and G. Celeux. Co-expression analysis of high-throughput transcriptome sequencing data with Poisson mixture models. Bioinformatics, 31(9):1420–1427, 2015.   \n45 [50] R. A. Redner and H. F. Walker. Mixture densities, maximum likelihood and the EM algorithm. SIAM review, 26(2):195–239, 1984.   \n47 [51] H. Robbins and S. Monro. A stochastic approximation method. The annals of mathematical statistics, pages 400–407, 1951.   \n49 [52] C. Robert and G. Casella. Monte Carlo statistical methods. Springer Science & Business Media, 2013. [53] W. Siblini, P. Kuntz, and F. Meyer. A review on dimensionality reduction for multi-label classification. IEEE Transactions on Knowledge and Data Engineering, 2019.   \n53 [54] J. P. Siebert. Vehicle recognition using rule based methods. 1987. [55] C. Viroli and G. J. McLachlan. Deep gaussian mixture models. Statistics and Computing, 29(1):43–51, 2019.   \n56 [56] C. F. J. Wu. On the convergence properties of the EM algorithm. The Annals of statistics, pages 95–103, 1983.   \n58 [57] D. Wu and J. Ma. An effective EM algorithm for mixtures of Gaussian processes via the MCMC sampling and approximation. Neurocomputing, 331:366–374, 2019. ",
+        "bbox": [
+            155,
+            85,
+            830,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "60 [58] W. Xiang, A. Karfoul, C. Yang, H. Shu, and R. L. B. Jeannès. An exact line search scheme to   \n61 accelerate the EM algorithm: Application to Gaussian mixture models identification. Journal of   \n62 computational science, 41:101073, 2020.   \n63 [59] M. Zhang, Y. Fu, K. M. Bennett, and T. Wu. Computational efficient variational Bayesian Gaus  \n64 sian mixture models via coreset. In 2016 International Conference on Computer, Information   \n65 and Telecommunication Systems (CITS), pages 1–5. IEEE, 2016.   \n66 [60] H. Zhao, P. Poupart, and G. Gordon. A unified approach for learning the parameters of sum  \n67 product networks. In Proceedings of the 30th International Conference on Neural Information   \n68 Processing Systems, pages 433–441, 2016. ",
+        "bbox": [
+            150,
+            90,
+            826,
+            237
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            131
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] Our main contribution is computational speedup. Cases where it was not achieved are highlighted in the experimental section.   \n(c) Did you discuss any potential negative societal impacts of your work? [No] We do not foresee any potential negative impact.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            267
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            215,
+            272,
+            493,
+            286
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            290,
+            736,
+            321
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            325,
+            393,
+            340
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The code is available in a github repository. All dataset are public from the UCI database.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Section 6.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] We report only average of Monte Carlo repetitions, the error bars were too small to have any visual impact in the reported logarithmic scale.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            238,
+            344,
+            825,
+            489
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            215,
+            494,
+            823,
+            510
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] We use 20 datasets from UCI, we cite the required papers for each dataset, mostly the UCI database and few additional publications.   \n(b) Did you mention the license of the assets? [No] The data are publically available, we comply with the requirement on citing appropriate publications.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            513,
+            825,
+            662
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            215,
+            666,
+            707,
+            681
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            685,
+            825,
+            773
+        ],
+        "page_idx": 13
+    }
+]