Add files using upload-large-folder tool

parse/train/BygqBiRcFQ/BygqBiRcFQ.md

@@ -0,0 +1,612 @@
+# DIFFUSION SCATTERING TRANSFORMS ON GRAPHS
+
+Fernando Gama   
+Dept. of Electrical and Systems Engineering   
+University of Pennsylvania   
+Alejandro Ribeiro   
+Dept. of Electrical and Systems Engineering   
+University of Pennsylvania   
+Joan Bruna   
+Courant Institute of Mathematical Sciences   
+New York University
+
+# ABSTRACT
+
+Stability is a key aspect of data analysis. In many applications, the natural notion of stability is geometric, as illustrated for example in computer vision. Scattering transforms construct deep convolutional representations which are certified stable to input deformations. This stability to deformations can be interpreted as stability with respect to changes in the metric structure of the domain.
+
+In this work, we show that scattering transforms can be generalized to nonEuclidean domains using diffusion wavelets, while preserving a notion of stability with respect to metric changes in the domain, measured with diffusion maps. The resulting representation is stable to metric perturbations of the domain while being able to capture “high-frequency” information, akin to the Euclidean Scattering.
+
+# 1 INTRODUCTION
+
+Convolutional Neural Networks (CNN) are layered information processing architectures. Each of the layers in a CNN is itself the composition of a convolution operation with a pointwise nonlinearity where the filters used at different layers are the outcome of a data-driven optimization process (LeCun et al., 2010; 2015). Scattering transforms have an analogous layered architecture but differ from CNNs in that the convolutional filters used at different layers are not trained but selected from a multi-resolution filter bank (Mallat, 2012; Bruna & Mallat, 2013). The fact that they are not trained endows scattering transforms with intrinsic value in situations where training is impossible – and inherent limitations in the converse case. That said, an equally important value of scattering transforms is that by isolating the convolutional layered architecture from training effects it permits analysis of the fundamental properties of CNN information processing architectures. This analysis is undertaken in Mallat (2012); Bruna & Mallat (2013) where the fundamental conclusion is about the stability of scattering transforms with respect to deformations in the underlying domain that are close to translations.
+
+In this paper we consider graphs and signals supported on graphs such as brain connectivity networks and functional activity levels (Huang et al., 2016), social networks and opinions (Jackson, 2008), or user similarity networks and ratings in recommendation systems (Huang et al., 2018). Our specific goals are: (i) To define a family of graph-scattering transforms. (ii) To define a notion of deformation for graph signals. (iii) To study the stability of graph scattering transforms with respect to this notion of deformation. To accomplish goal (i) we consider the family of graph diffusion wavelets which provide an appropriate construction of a multi-resolution filter bank (Coifman & Maggioni, 2006). Our diffusion scattering transforms are defined as the layered composition of diffusion wavelet filter banks and pointwise nonlinearities. To accomplish goal (ii) we adopt the graph diffusion distance as a measure of deformation of the underlying domain (Coifman & Lafon, 2006; Nadler et al., 2006). Diffusion distances measure the similarity of two graphs through the time it takes for a signal to be diffused on the graph. The major accomplishment of this paper is to show that the diffusion graph scattering transforms are stable with respect to deformations as measured with respect to diffusion distances. Specifically, consider a signal $\mathbf { x }$ supported on graph $G$ whose diffusion scattering transform is denoted by the operator $\Psi _ { G }$ . Consider now a deformation of the signal’s domain so that the signal’s support is now described by the graph $G ^ { \prime }$ whose diffusion scattering operator is $\Psi _ { G ^ { \prime } }$ . We show that the operator norm distance $\| \Psi _ { G } - \Psi _ { G ^ { \prime } } \|$ is bounded by a constant multiplied by the diffusion distance between the graphs $G$ and $G ^ { \prime }$ . The constant in this bound depends on the spectral gap of $G$ but, very importantly, does not depend on the number of nodes in the graph.
+
+It is important to point out that finding stable representations is not difficult. E.g., taking signal averages is a representation that is stable to domain deformations – indeed, invariant. The challenge is finding a representation that is stable and rich in its description of the signal. In our numerical analyses we show that linear filters can provide representations that are either stable or rich but that cannot be stable and rich at the same time. The situation is analogous to (Euclidean) scattering transforms and is also associated with high frequency components. We can obtain a stable representation by eliminating high frequency components but the representation loses important signal features. Alternatively, we can retain high frequency components to have a rich representation but that representation is unstable to deformations. Diffusion scattering transforms are observed to be not only stable – as predicted by our theoretical analysis – but also sufficiently rich to achieve good performance in graph signal classification examples.
+
+# 2 RELATED WORK
+
+Since graph and graph signals are of increasing interest but do not have the regular structure that would make use of CNNs appealing, it is pertinent to ask the question of what should be an appropriate generalization of CNNs to graphs and the graph signals whose topology they describe (Bronstein et al., 2017). If one accepts the value of convolutions as prima facie, a natural solution is to replace convolutions with graph shift invariant filters which are known to be valid generalizations of (convolutional) time invariant filters (Bruna et al., 2014). This idea is not only natural but has been demonstrated to work well in practical implementations of Graph Neural Networks (GNNs) (Defferrard et al., 2016; Gama et al., 2019; Gilmer et al., 2017; Henaff et al., 2015; Kipf & Welling, 2017). Same as Euclidean scattering transforms, our graph scattering transforms differ from GNNs in that they do not have to be trained. The advantages and limitations of the absence of training notwithstanding, our work also sheds light on the question of why graph convolutions are appropriate generalizations of regular domain convolutions for signal classification problems. Our work suggests that the value of GNNs stems from their stability relative to deformations of the underlying domain that are close to permutations – which is the property that a pair of graphs must satisfy to have small diffusion distance.
+
+The stability results obtained in this paper build on the notion of scattering transforms. These scattering representations were introduced by Mallat (2012) and further developed in Bruna & Mallat (2013) with computer vision applications. Since, these representations have been extended to handle transformations on more complex groups, such as roto-translations (Sifre & Mallat, 2013; Oyallon & Mallat, 2015), and to domains such as audio processing (Anden & Mallat, 2014) and quantum ´ chemistry (Eickenberg et al., 2017).
+
+Similarly as in this work, extensions of scattering to general graphs have been considered in Chen et al. (2014) and Zou & Lerman (2018). Chen et al. (2014) focuses on Haar wavelets that hierarchically coarsen the graph, and relies on building multiresolution pairings. The recent Zou & Lerman (2018) is closest to our work. There, the authors define graph scattering using spectrally constructed wavelets from (Hammond et al., 2011), and establish some properties of the resulting representation, such as energy conservation and stability to spectral perturbations. In contrast, our stability results are established with respect to diffusion metric perturbations, which are generally weaker, in the sense that they define a weaker topology (see Section 3). We use diffusion wavelets (Coifman & Maggioni, 2006) to obtain multi-resolution graph filter banks that are localized in frequency as well as in the graph domain, while spanning the whole spectrum. Diffusion wavelets serve as the constructive basis for the obtained stability results. Our work is also closely related to recent analysis of stability of Graph Neural Networks in the context of surface representations in (Kostrikov et al., 2017). In our work, however, we do not rely on extrinsic deformations and exploit the specific multiresolution structure of wavelets.
+
+# 3 PROBLEM SET-UP
+
+This section introduces our framework and states the desired stability properties of signal representations defined on general non-Euclidean domains.
+
+# 3.1 EUCLIDEAN STABILITY TO DEFORMATIONS WITH SCATTERING
+
+Motivated by computer vision applications, our analysis starts with the notion of deformation stability. If $\mathbf { x } ( \bar { u } ) \in \bar { L ^ { 2 } } ( \Omega )$ is an image defined over an Euclidean domain $\Omega \subset \mathbb { R } ^ { d }$ , we are interested in signal representations $\Phi : L ^ { 2 } ( \bar { \Omega } ) \to \mathbb { R } ^ { K }$ that are stable with respect to small deformations. If $\mathbf { x } _ { \tau } ( \bar { u } ) : = \bar { \mathbf { x } ( } u - \tau ( u ) )$ denotes a change of variables with a differentiable field $\tau : \Omega  \Omega$ such that $\| \nabla \tau \| < 1$ , then we ask
+
+$$
+\forall \mathbf { x } , \tau , \lVert \Phi ( \mathbf { x } ) - \Phi ( \mathbf { x } _ { \tau } ) \rVert \lesssim \lVert \mathbf { x } \rVert \lVert \tau \rVert , \mathrm { w i t h }
+$$
+
+$\| \tau \| : = \| \nabla \tau \| _ { \infty }$ denoting a uniform bound on the operator norm of $\nabla \tau$ . In this setting, a notorious challenge to achieving (1) while keeping enough discriminative power in $\Phi ( \mathbf { x } )$ is to transform the high-frequency content of $\mathbf { x }$ in such a way that it becomes stable.
+
+Scattering transforms (Mallat, 2012; Bruna & Mallat, 2013) provide such representations by cascading wavelet decompositions with pointwise modulus activation functions. We briefly summarize here their basic definition. Given a mother wavelet $\psi \in L ^ { 1 } ( \Omega )$ with at least a vanishing moment $\textstyle \int { \psi ( u ) d u } = 0$ and with good spatial localization, we consider rotated and dilated versions $\psi _ { j , c } ( u ) = 2 ^ { - j d } \psi ( 2 ^ { - j } R _ { c } u )$ using scale parameter $j$ and angle $\theta \in \{ 2 \pi c / C \} _ { c = 0 , \ldots , C - 1 }$ . A wavelet decomposition operator is defined as a filter bank spanning all scales up to a cutoff $2 ^ { J }$ and all angles: $\Psi _ { J } : \bar { \mathbf { x } } \mapsto ( \mathbf { x } \ast \bar { \psi } _ { j , c } ) _ { j \leq J , c \leq C }$ . This filter bank is combined with a pointwise modulus activation function $\rho ( z ) = | z |$ , as well as a low-pass average pooling operator $U$ computing the average over the domain. The resulting representation using $m$ layers becomes
+
+$$
+\begin{array} { l l l } { \Phi ( \mathbf { x } ) } & { = } & { \left\{ S _ { 0 } ( \mathbf { x } ) , S _ { 1 } ( \mathbf { x } ) , \ldots , S _ { m - 1 } ( \mathbf { x } ) \right\} , \mathrm { w i t h } } \\ { S _ { k } ( \mathbf { x } ) } & { = } & { U \rho \Psi _ { J } \rho \ldots \Psi _ { J } \mathbf { x } = \{ U ( | | \mathbf { x } * \psi _ { \alpha _ { 1 } } | * \psi _ { \alpha _ { 2 } } | \ldots * \psi _ { \alpha _ { k } } | ) ; \} _ { \alpha _ { 1 } , \ldots , \alpha _ { k } } ( k = 0 , \ldots , m - 1 ) } \end{array}
+$$
+
+The resulting signal representation has the structure of a CNN, in which feature maps are not recombined with each other, and trainable filters are replaced by multiscale, oriented wavelets. It is shown in Mallat (2012) that for appropriate signal classes and wavelet families, the resulting scattering transform satisfies a deformation stablity condition of the form (1), which has been subsequently generalised to broader multiresolution families (Wiatowski & Bolcskei, 2018). In essence, ¨ the mechanism that provides stability is to capture high-frequency information with the appropriate spatio-temporal tradeoffs, using spatially localized wavelets.
+
+# 3.2 DEFORMATIONS AND METRIC STABILITY
+
+Whereas deformations provide the natural framework to describe geometric stability in Euclidean domains, their generalization to non-Euclidean, non-smooth domains is not straightforward. Let $\mathbf { x } \in L ^ { 2 } ( \mathcal { X } )$ . If $\mathcal { X }$ is embedded into a low-dimension Euclidean space $\Omega \subset \overline { { \mathbb { R } } } ^ { d }$ , such as a 2- surface within a three-dimensional space, then one can still define meaningful deformations on $\mathcal { X }$ via extrinsic deformations of $\Omega$ (Kostrikov et al., 2017).
+
+However, in this work we are interested in intrinsic notions of geometric stability, that do not necessarily rely on a pre-existent low-dimensional embedding of the domain. The change of variables $\varphi ( u ) = u - \tau ( u )$ defining the deformation can be seen as a perturbation of the Euclidean metric in $L ^ { 2 } ( \mathbb { R } ^ { d } )$ . Indeed,
+
+$$
+\langle \mathbf { x } _ { \tau } , \mathbf { y } _ { \tau } \rangle _ { L ^ { 2 } ( \mathbb { R } ^ { d } , \mu ) } = \int _ { \mathbb { R } ^ { d } } \mathbf { x } _ { \tau } ( u ) \mathbf { y } _ { \tau } ( u ) d \mu ( u ) = \int _ { \mathbb { R } ^ { d } } \mathbf { x } ( u ) \mathbf { y } ( u ) | I - \nabla \tau ( u ) | d \mu ( u ) = \langle \mathbf { x } , \mathbf { y } \rangle _ { L ^ { 2 } ( \mathbb { R } ^ { d } , \tilde { \mu } ) } ,
+$$
+
+with $d \tilde { \mu } ( u ) = | I - \nabla \tau ( u ) | d \mu ( u )$ , and $| I - \nabla \tau ( u ) | \approx 1$ if $\| \nabla \tau \|$ is small, where $I$ is the identity. Therefore, a possible way to extend the notion of deformation stability to general domains $L ^ { 2 } ( \dot { \mathcal { X } } )$ is to think of $\mathcal { X }$ as a metric space and reason in terms of stability of $\bar { \Phi } : \bar { L ^ { 2 } } ( \mathcal { X } ) \to \mathbb { R } ^ { K }$ to metric changes in $\mathcal { X }$ . This requires a representation that can be defined on generic metric spaces, as well as a criteria to compare how close two metric spaces are.
+
+# 3.3 DIFFUSION WAVELETS AND METRICS ON GRAPHS
+
+Graphs are flexible data structures that enable general metric structures and modeling non-Euclidean domains. The main ingredients of the scattering transform can be generalized using tools from computational harmonic analysis on graphs. We note that, unlike the case of Euclidean domains, where deformations are equivalent whether they are analyzed from the function domain or its image, in the case of graphs, we focus on deformations on the underlying graph domain, while keeping the same function mapping (i.e. we model deformations as a change of the underlying graph support and analyze how this affects the interaction between the function mapping and the graph).
+
+In particular, diffusion wavelets (Coifman & Maggioni, 2006) provide a simple framework to define a multi-resolution analysis from powers of a diffusion operator defined on a graph. A weighted, undirected graph $G = ( V , E , W )$ with $| V | = n$ nodes, edge set $E$ and adjacency matrix $W \in \mathbb { R } ^ { n \times n }$ defines a diffusion process $A$ in its nodes, given in its symmetric form by the normalized adjacency
+
+$$
+A : = D ^ { - 1 / 2 } W D ^ { - 1 / 2 } , \mathrm { w i t h } D = \mathrm { d i a g } ( d _ { 1 } , \dots , d _ { n } ) ,
+$$
+
+where $\begin{array} { r } { d _ { i } = \sum _ { ( i , j ) \in E } W _ { i , j } } \end{array}$ denotes the degree of node $i$ . Denote by $\mathbf { d } = W \mathbf { 1 }$ the degree vector containing $d _ { i }$ in the ith element. By construction, $A$ is well-localized in space (it is nonzero only where there is an edge connecting nodes), it is self-adjoint and satisfies $\| A \| \leq 1$ , where $\| A \|$ is the operator norm. Let √ √ $\lambda _ { 0 } \geq \lambda _ { 1 } \geq . . . \lambda _ { n - 1 }$ denote its eigenvalues in decreasing order. Defining ${ \bf d } ^ { 1 / 2 } = ( \sqrt { d _ { 1 } } , \dots , \sqrt { d _ { n } } )$ , one can easily verify that the normalized squared root degree vector $\mathbf { v } = \mathbf { d } ^ { 1 / 2 } / \lVert \mathbf { d } ^ { 1 / 2 } \rVert _ { 2 } = \mathbf { d } / \lVert \mathbf { d } \rVert _ { 1 }$ is the eigenvector with associated eigenvalue $\lambda _ { 0 } = 1$ . Also, note that $\lambda _ { n - 1 } = - 1$ if and only if $G$ has a connected component that is non-trivial and bipartite (Chung, 1997).
+
+In the following, it will be convenient to assume that the spectrum of $A$ (which is real and discrete since $A$ is self-adjoint and in finite-dimensions) is non-negative. Since we shall be taking powers of $A$ , this will avoid folding negative eigenvalues into positive ones. For that purpose, we adopt the so-called lazy diffusion, given by $T = { \frac { 1 } { 2 } } ( I + A )$ . In Section 4 we use this diffusion operator to define both a multiscale wavelet filter bank and a low-pass average pooling, leading to the diffusion scattering representation.
+
+This diffusion operator can also be used to construct a metric on $G$ . The so-called diffusion distances (Coifman & Lafon, 2006; Nadler et al., 2006) measure distances between two nodes $x , x ^ { \prime } \in V$ in terms of their associated diffusion at time $s$ : $d _ { G , s } ( x , x ^ { \prime } ) = \Vert T _ { G } ^ { s } \delta _ { x } - T _ { G } ^ { s } \delta _ { x ^ { \prime } } \Vert$ , where $\delta _ { x }$ is a vector with all zeros except a 1 in position $x$ .
+
+In this work, we build on this diffusion metric to define a distance between two graphs $G , G ^ { \prime }$ . Assuming first that $G$ and $G ^ { \prime }$ have the same size, the simplest formulation is to compare the diffusion metric generated by $G$ and $G ^ { \prime }$ up to a node permutation:
+
+Definition 3.1. Let $G = ( V , E , W )$ , $G ^ { \prime } = ( V ^ { \prime } , E ^ { \prime } , W ^ { \prime } )$ have the same size $| V | = | V ^ { \prime } | = n$ . The normalized diffusion distance between graphs $G$ , $G ^ { \prime }$ at time $s > 0$ is
+
+$$
+\mathrm { d } ^ { s } ( G , G ^ { \prime } ) : = \operatorname* { i n f } _ { \Pi \in \Pi _ { n } } \Vert ( T _ { G } ^ { s } ) ^ { * } ( T _ { G } ^ { s } ) - \Pi ^ { \boldsymbol { \mathsf { T } } } ( T _ { G ^ { \prime } } ^ { s } ) ^ { * } ( T _ { G ^ { \prime } } ^ { s } ) \Pi \Vert = \operatorname* { i n f } _ { \Pi \in \Pi _ { n } } \Vert T _ { G } ^ { 2 s } - \Pi ^ { \boldsymbol { \mathsf { T } } } T _ { G ^ { \prime } } ^ { 2 s } \Pi \Vert ,
+$$
+
+where $\Pi _ { n }$ is the space of $n \times n$ permutation matrices.
+
+The diffusion distance is defined at a specific time $s$ . As $s$ increases, this distance becomes weaker1, since it compares points at later stages of diffusion. The role of time is thus to select the smoothness of the ‘graph deformation’, similarly as $\| \nabla \tau \|$ measures the smoothness of the deformation in the Euclidean case. For convenience, we denote $\operatorname { d } ( G , G ^ { \prime } ) = \mathrm { d } ^ { 1 / 2 } ( G , G ^ { \prime } )$ and use the distance at $s =$ $1 / 2$ as our main deformation measure. The quantity d defines a distance between graphs (seen as metric spaces) yielding a stronger topology than other alternatives such as the Gromov-Hausdorff distance, defined as
+
+$$
+d _ { \mathrm { G H } } ^ { s } ( G , G ^ { \prime } ) = \operatorname* { i n f } _ { \Pi } \operatorname* { s u p } _ { x , x ^ { \prime } \in V } | d _ { G } ^ { s } ( x , x ^ { \prime } ) - d _ { G ^ { \prime } } ^ { s } ( \pi ( x ) , \pi ( x ^ { \prime } ) ) |
+$$
+
+with $d _ { G } ^ { s } ( x , x ^ { \prime } ) = \lVert T _ { G } ^ { t } ( \delta _ { x } - \delta _ { x ^ { \prime } } ) \rVert _ { L ^ { 2 } ( G ) }$ . We choose $\mathrm { d } ( G , G ^ { \prime } )$ in this work for convenience and mathematical tractability, but leave for future work the study of stability relative to $d _ { \mathrm { G H } } ^ { s }$ . Finally,
+
+we consider for simplicity only the case where the sizes of $G$ and $G ^ { \prime }$ are equal, but definition (3.1) can be naturally extended to compare variable-sized graphs by replacing permutations by softcorrespondences (see Bronstein et al., 2010).
+
+# 3.4 PROBLEM STATEMENT
+
+Our goal is to build a stable and rich representation $\Phi _ { G } ( \mathbf { x } )$ . The stability property is stated in terms of the diffusion metric above: For a chosen diffusion time $s , \forall \textbf { x } \in \mathbb { R } ^ { n }$ , $G = ( V , E , W ) , G ^ { \prime } =$ $( V ^ { \prime } , E ^ { \prime } , W ^ { \prime } )$ with $| V | = | V ^ { \prime } | = n$ , we want
+
+$$
+\begin{array} { r } { \| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \| \lesssim \| \mathbf { x } \| \mathrm { d } ^ { s } ( G , G ^ { \prime } ) . } \end{array}
+$$
+
+This representation can be used to model both signals and domains, or just domains $G$ , by considering a prespecified $\mathbf { x } = f ( G )$ , such as the degree, or by marginalizing from an exchangeable distribution, $\Phi _ { G } = \mathbb { E } _ { \mathbf { x } \sim Q } \Phi _ { G } ( \mathbf { x } )$ .
+
+The motivation of (5) is two-fold: On the one hand, we are interested in applications where the signal of interest may be measured in dynamic environments that modify the domain, e.g. in measuring brain signals across different individuals. On the other hand, in other applications, such as building generative models for graphs, we may be interested in representing the domain $G$ itself. A representation from the adjacency matrix of $G$ needs to build invariance to node permutations, while capturing enough discriminative information to separate different graphs. In particular, and similarly as with Gromov-Hausdorff distances, the definition of $\mathrm { d } ( G , G ^ { \prime } )$ involves a matching problem between two kernel matrices, which defines an NP-hard combinatorial problem. This further motivates the need for efficient representations of graphs $\Phi _ { G }$ that can efficiently tell apart two graphs, and such that $\ell ( \theta ) = \| \Phi _ { G } - \Phi _ { G ( \theta ) } \|$ can be used as a differentiable loss for training generative models.
+
+# 4 GRAPH DIFFUSION SCATTERING
+
+Let $T$ be a lazy diffusion operator associated with a graph $G$ of size $n$ such as those described in Section 3.3. Following Coifman & Maggioni (2006), we construct a family of multiscale filters by exploiting the powers of the diffusion operator $T ^ { 2 ^ { j } }$ . We define
+
+$$
+\psi _ { 0 } : = I - T , \psi _ { j } : = T ^ { 2 ^ { j - 1 } } ( I - { T ^ { 2 ^ { j - 1 } } } ) = { T ^ { 2 ^ { j - 1 } } } - { T ^ { 2 ^ { j } } } , ( j > 0 ) .
+$$
+
+This corresponds to a graph wavelet filter bank with optimal spatial localization. Graph diffusion wavelets are localized both in space and frequency, and favor a spatial localization, since they can be obtained with only two filter coefficients, namely $h _ { 0 } ~ = ~ 1$ for diffusion $T ^ { 2 ^ { j - 1 } }$ and $h _ { 1 } ~ = ~ - 1$ for diffusion $T ^ { 2 ^ { j } }$ . The finest scale $\psi _ { 0 }$ corresponds to one half of the normalized Laplacian operator $\psi _ { 0 } = ( 1 / 2 ) \Delta = 1 / 2 ( I - D ^ { - 1 / 2 } W D ^ { - 1 / 2 } )$ , here seen as a temporal difference in a diffusion process, seeing each diffusion step (each multiplication by $\Delta$ ) as a time step. The coarser scales $\psi _ { j }$ capture temporal differences at increasingly spaced diffusion times. For $j = 0 , \ldots , J _ { n } - 1$ , we consider the linear operator
+
+$$
+\begin{array} { r c l } { \Psi : L ^ { 2 } ( G ) } & { \to } & { ( L ^ { 2 } ( G ) ) ^ { J _ { n } } } \\ { \mathbf { x } } & { \mapsto } & { ( \psi _ { j } \mathbf { x } ) _ { j = 0 , \ldots , J _ { n } - 1 } , } \end{array}
+$$
+
+which is the analog of the wavelet filter bank in the Euclidean domain. Whereas several other options exist to define graph wavelet decompositions (Rustamov & Guibas, 2013; Gavish et al., 2010), and GNN designs that favor frequency localization, such as Cayley filters (Levie et al., 2019), we consider here wavelets that can be expressed with few diffusion terms, favoring spatial over frequential localization, for stability reasons that will become apparent next. We choose dyadic scales for convenience, but the construction is analogous if one replaces scales $2 ^ { j }$ by $\lceil \gamma ^ { j } \rceil$ for any $\gamma > 1$ in (6).
+
+If the graph $G$ exhibits a spectral gap, i.e., $\beta _ { G } = \operatorname* { s u p } _ { i = 1 , \dots n - 1 } | \lambda _ { i } | < 1$ , the following proposition proves that the linear operator $\Psi$ defines a stable frame.
+
+Proposition 4.1. For each $n$ , let $\Psi$ define the diffusion wavelet decomposition (7) and assume $\beta _ { G } < 1$ . Then there exists a constant $0 < C ( \beta )$ depending only on $\beta$ such that for any $\mathbf { x } \in \mathbb { R } ^ { n }$
+
+satisfying $\langle \mathbf { x } , \mathbf { v } \rangle = 0$ ,
+
+$$
+C ( \boldsymbol { \beta } ) \| \mathbf { x } \| ^ { 2 } \leq \sum _ { j = 0 } ^ { J _ { n } - 1 } \| \psi _ { j } \mathbf { x } \| ^ { 2 } \leq \| \mathbf { x } \| ^ { 2 } .
+$$
+
+This proposition thus provides the Littlewood-Paley bounds of $\Psi$ , which control the ability of the filter bank to capture and amplify the signal $\mathbf { x }$ along each ‘frequency’ (i.e. the ability of the filter to increase or decrease the energy of the representation, relative to the energy of the $\mathbf { x }$ ). We note that diffusion wavelets are neither unitary nor analytic and therefore do not preserve energy. However, the frame bounds in Proposition 4.1 provide lower bounds on the energy lost, such that the smaller $1 - \ \beta$ is, the less “unitary” our diffusion wavelets are. It also informs us about how the spectral gap $\beta$ determines the appropriate diffusion scale $J$ : The maximum of $p ( u ) = ( u ^ { r } - u ^ { 2 r } ) ^ { 2 }$ is at $u = 2 ^ { - 1 / r }$ , thus the cutoff $r _ { * }$ should align with $\beta$ as $\begin{array} { r } { r _ { * } = \frac { - 1 } { \log _ { 2 } \beta } } \end{array}$ −1log β , since larger values of r capture energy in a spectral range where the graph has no information. Therefore, the maximum scale can be adjusted as $\begin{array} { r } { J = \lceil 1 + \log _ { 2 } r _ { * } \rceil = 1 + \left\lceil \log _ { 2 } \left( \frac { - 1 } { \log _ { 2 } \beta } \right) \right\rceil } \end{array}$ .
+
+Recall that the Euclidean Scattering transform is constructed by cascading three building blocks: a wavelet decomposition operator, a pointwise modulus activation function, and an averaging operator. Following the Euclidean scattering, given a graph $G$ and $\mathbf { x } \in L ^ { 2 } ( G )$ , we define an analogous Diffusion Scattering transform $\Phi _ { G } ( \mathbf { x } )$ by cascading three building blocks: the Wavelet decomposition operator $\Psi$ , a pointwise activation function $\rho$ , and an average operator $U$ which extracts the average over the domain. The average over a domain can be interpreted as the diffusion at infinite time, thus $U \mathbf { x } = \operatorname* { l i m } _ { t \to \infty } T ^ { t } \mathbf { x } = \langle \mathbf { v } ^ { \mathsf { T } } , \mathbf { x } \rangle$ . More specifically, we consider a first layer transformation given by
+
+$$
+\phi _ { 1 } ( G , { \bf x } ) = U \rho \Psi \bf x = \{  U \rho \psi _ { \boldsymbol \rho } \bf x \} _ { 0 \leq { j \leq J _ { n } - 1 } } \ ,
+$$
+
+followed by second order coefficients
+
+$$
+\phi _ { 2 } ( G , { \bf x } ) = U \rho \Psi \rho \Psi { \bf x } = \{ U \rho \psi _ { j _ { 2 } } \rho \psi _ { j _ { 1 } } { \bf x } \} _ { 0 \leq j _ { 1 } , j _ { 2 } \leq J _ { n } - 1 } , ,
+$$
+
+and so on. The representation obtained from $m$ layers of such transformation is thus
+
+$$
+\Phi _ { G } ( { \bf x } ) = \left\{ U x , \phi _ { 1 } ( G , { \bf x } ) , \ldots , \phi _ { m - 1 } ( G , { \bf x } ) \right\} = \left\{ U ( \rho \Psi ) ^ { k } { \bf x } ; k = 0 , \ldots , m - 1 \right\} .
+$$
+
+# 5 STABILITY OF GRAPH DIFFUSION SCATTERING
+
+# 5.1 STABILITY AND EQUIVARIANCE OF DIFFUSION WAVELETS
+
+Given two graphs $G , G ^ { \prime }$ of size $n$ and a signal $\mathbf { x } \in \mathbb { R } ^ { n }$ , our objective is to bound $\left\| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \right\|$ in terms of $\mathrm { d } ( G , G ^ { \prime } )$ . Let $\pi _ { * }$ the permutation minimising the distortion between $G$ and $G ^ { \prime }$ in (4). Since all operations in $\Phi$ are either equivariant or invariant with respect to permutations, we can assume w.l.o.g. that $\pi = 1$ , so that the diffusion distance can be directly computed by comparing nodes with the given order. A key property of $G$ that drives the stability of the diffusion scattering is given by its spectral gap $1 - \beta _ { G } = 1 - \operatorname* { s u p } _ { i = 1 , \dots n - 1 } | \lambda _ { i } | \geq 0$ . In the following, we use $\ell _ { 2 }$ operator norms, unless stated otherwise.
+
+Lemma 5.1. Assume $\beta : = \operatorname* { m a x } ( \beta _ { G } , \beta _ { G ^ { \prime } } ) < 1$ . Then
+
+$$
+\operatorname* { i n f } _ { \Pi \in \Pi _ { n } } \| \Psi _ { G } - \Pi \Psi _ { G ^ { \prime } } \Pi ^ { \mathsf { T } } \| \leq 2 \mathrm { d } ( G , G ^ { \prime } ) \sqrt { \frac { \beta ^ { 2 } ( 1 + \beta ^ { 2 } ) } { ( 1 - \beta ^ { 2 } ) ^ { 3 } } } .
+$$
+
+Remark: If diffusion distance is measured at time different from $s = 1 / 2$ , the stability bound would be modified due to scales $j$ such that $2 ^ { j } < s$ .
+
+The following lemma studies the stability of the low-pass operator $U$ with respect to graph perturbations.
+
+Lemma 5.2. Let $G , G ^ { \prime }$ be two graphs with same size, denote by v and $\mathbf { v } ^ { \prime }$ their respective squaredroot degree vectors, and by $\beta , \beta ^ { \prime }$ their spectral gap. Then
+
+$$
+\operatorname* { i n f } _ { \Pi \in \Pi _ { n } } \| \mathbf { v } - \Pi \mathbf { v } ^ { \prime } \| ^ { 2 } \leq 2 \frac { \mathrm { d } ( G , G ^ { \prime } ) } { 1 - \operatorname* { m i n } ( \beta , \beta ^ { \prime } ) } .
+$$
+
+Spectral Gap asymptotic behavior Lemmas 5.1 and 5.2 leverage the spectral gap of the lazy diffusion operator associated with $G$ . In some cases, such as regular graphs, the spectral gap vanishes asymptotically as $n \to \infty$ , thus degrading the upper bound asymptotically. Improving the bound by leveraging other properties of the graph (such as regular degree distribution) is an important open task.
+
+# 5.2 STABILITY AND INVARIANCE OF DIFFUSION SCATTERING
+
+The scattering transform coefficients $\Phi _ { G } ( \mathbf { x } )$ obtained after $m$ layers are given by equation 11, for low-pass operator $U$ such that $U \mathbf { x } = \langle \mathbf { v } , \mathbf { x } \rangle$ so that $U = \mathbf { v } ^ { \mathsf { T } }$ .
+
+From Lemma 5.1 we have that, $\| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| \leq \varepsilon _ { \Psi } = 2 \mathrm { d } ( G , G ^ { \prime } ) \sqrt { \beta ^ { 2 } ( 1 + \beta ^ { 2 } ) / ( 1 - \beta ^ { 2 } ) ^ { 3 } }$ . We also know, from Proposition 4.1 that $\Psi$ conforms a frame, i.e. $C ( \beta ) \| \mathbf { x } \| ^ { 2 } \leq \| \Psi \mathbf { x } \| ^ { 2 } \leq \| \mathbf { x } \| ^ { 2 }$ fo r known constant $C ( \beta )$ given in Prop. 4.1. Additionally, from Lemma 5.2 we get that $\left\| U _ { G } - U _ { G ^ { \prime } } \right\| \leq$ $\varepsilon _ { U } = 2 \mathrm { d } ( G , G ^ { \prime } ) / ( 1 - \operatorname* { m i n } ( \beta , \beta ^ { \prime } ) )$ .
+
+The objective now is to prove stability of the scattering coefficients $\Phi _ { G } ( \mathbf { x } )$ , that is, to prove that
+
+$$
+\begin{array} { r } { \| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \| \lesssim \mathrm { d } ( G , G ^ { \prime } ) \| \mathbf { x } \| . } \end{array}
+$$
+
+This is captured in the following Theorem:
+
+Theorem 5.3. Let $G , G ^ { \prime }$ be two graphs and let $\mathrm { d } ( G , G ^ { \prime } )$ be their distance measured as in equation 4. Let $T _ { G }$ and $T _ { G ^ { \prime } }$ be the respective diffusion operators. Denote by $U _ { G } , \rho _ { G }$ and $\Psi _ { G }$ and by $U _ { G ^ { \prime } } , \rho _ { G ^ { \prime } }$ and $\Psi _ { G ^ { \prime } }$ the low pass operator, pointwise nonlinearity and the wavelet filter bank used on the scattering transform defined on each graph, respectively, cf. equation $1 l$ . Assume $\rho _ { G } = \rho _ { G ^ { \prime } }$ and that $\rho _ { G }$ is non-expansive. Let $\beta _ { - } = \operatorname* { m i n } ( \beta _ { G } , \beta _ { G ^ { \prime } } )$ , $\beta _ { + } = \operatorname* { m a x } ( \beta _ { G } , \beta _ { G ^ { \prime } } )$ and assume $\beta _ { + } < 1$ . Then, we have that, for each $k = 0 , \ldots , m - 1$ , the following holds
+
+$$
+\| U _ { G } ( \rho _ { G } \Psi _ { G } ) ^ { k } - U _ { G ^ { \prime } } ( \rho _ { G ^ { \prime } } \Psi _ { G ^ { \prime } } ) ^ { k } \| \leq \left( \frac { 2 } { 1 - \beta _ { - } } \mathrm { d } ( G , G ^ { \prime } ) \right) ^ { 1 / 2 } + k \sqrt { \frac { \beta _ { + } ^ { 2 } ( 1 + \beta _ { + } ^ { 2 } ) } { ( 1 - \beta _ { + } ^ { 2 } ) ^ { 3 } } } \mathrm { d } ( G , G ^ { \prime } ) .
+$$
+
+Defining forward t $\begin{array} { r } { \| \Phi _ { G } ( \mathbf { x } ) \| ^ { 2 } = \sum _ { k = 0 } ^ { m - 1 } \| U _ { G } ( \rho _ { G } \Psi _ { G } ) ^ { k } \| ^ { 2 } } \end{array}$ analogously to Bruna & Mallat (2013), it is straight-cattering coefficients as follows.
+
+Corollary 5.4. In the context of Theorem 5.3, let $\mathbf { x } \in \mathbb { R } ^ { n }$ and let $\Phi _ { G } ( \mathbf { x } )$ be the scattering coefficients computed by means of equation $_ { l I }$ on graph $G$ after $m$ layers, and let $\ { \Phi } _ { G ^ { \prime } } ( { \bf x } )$ be the corresponding coefficients on graph $G ^ { \prime }$ . Then,
+
+$$
+\begin{array} { r l } & { \| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \| ^ { 2 } \leq \displaystyle \sum _ { k = 0 } ^ { m - 1 } \bigg [ \bigg ( \frac { 2 } { 1 - \beta _ { - } } \mathrm { d } ( G , G ^ { \prime } ) \bigg ) ^ { 1 / 2 } + k \sqrt { \frac { \beta _ { + } ^ { 2 } ( 1 + \beta _ { + } ^ { 2 } ) } { ( 1 - \beta _ { + } ^ { 2 } ) ^ { 3 } } } \mathrm { d } ( G , G ^ { \prime } ) \bigg ] ^ { 2 } \| \mathbf { x } \| ^ { 2 } } \\ & { \| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \| \lesssim m ^ { 1 / 2 } \mathrm { d } ^ { 1 / 2 } ( G , G ^ { \prime } ) \| \mathbf { x } \| ~ i f \mathrm { d } ( G , G ^ { \prime } ) \ll 1 . } \end{array}
+$$
+
+Corollary 5.4 satisfies equation 5. It also shows that the closer the graphs are in terms of the diffusion metric, the closer their scattering representations will be. The constant is given by topological properties, the spectral gaps of $G$ and $G ^ { \prime }$ , as well as design parameters, the number of layers $m$ . We observe that the stability bound grows the smaller the spectral gap is and also as more layers are considered. The spectral gap is tightly linked with diffusion processes on graphs, and thus it does emerge from the choice of a diffusion metric. Graphs with values of beta closer to 1, exhibit weaker diffusion paths, and thus a small perturbation on the edges of these graphs would lead to a larger diffusion distance. The contrary holds as well. In other words, the tolerance of the graph to edge perturbations (i.e., $\mathrm { d } ( G , G )$ being small) depends on the spectral gap of the graph. We also note that, as stated at the end of Section 5.1, the spectral gap appears in our upper bounds, but it is not necessarily sharp. In particular, the spectral gap is a poor indication of stability in regular graphs, and we believe our bound can be improved by leveraging structural properties of regular domains.
+
+Finally, we note that the size of the graphs impacts the stability result inasmuch as it impacts the distance measure $\mathrm { d } ( G , G ^ { \prime } )$ . This is expected, since graphs of different size can be compared, as mentioned in Section 3.3. Different from Zou & Lerman (2018), our focus is on obtaining graph wavelet banks that are localized in the graph domain to improve computational efficiency as discussed in Defferrard et al. (2016). We also notice that the scattering transform in Zou & Lerman (2018) is stable with respect to a graph measure that depends on the spectrum of the graph through both eigenvectors and eigenvalues. More specifically, it is required that the spectrum gets concentrated as the graphs grow. However, in general, it is not straightforward to relate the topological structure of the graph with its spectral properties.
+
+As mentioned in Section 3.3, the stability is computed with a metric $\mathrm { d } ( G , G ^ { \prime } )$ which is stronger than what could be hoped for. Our metric is permutation-invariant, in analogy with the rigid translation invariance in the Euclidean case, and stable to small perturbations around permutations. The extension of (16) to weaker metrics, using e.g. multiscale deformations, is left for future work.
+
+# 5.3 FROM DIFFUSION SCATTERING TO DIFFUSION GNNS
+
+By denoting $T _ { j } \ = \ T ^ { 2 ^ { j } }$ , observe that one can approximate the diffusion wavelets from (6) as a cascade of low-pass diffusions followed by a high-pass filter at resolution $2 ^ { j }$ :
+
+$$
+\psi _ { j } = T _ { j - 1 } ( I - T _ { j - 1 } ) \approx T ^ { \sum _ { j ^ { \prime } < j - 1 } 2 ^ { j ^ { \prime } } } ( I - T _ { j - 1 } ) = \left( \prod _ { j ^ { \prime } < j - 1 } T _ { j ^ { \prime } } \right) ( I - T _ { j - 1 } ) .
+$$
+
+This pyramidal structure of multi-resolution analysis wavelets — in which each layer now corresponds to a different scale, shows that the diffusion scattering is a particular instance of GNNs where each layer $j$ is generated by the pair of operators $\{ I , T _ { j - 1 } \}$ . If $\mathbf { x } ^ { ( j ) } \in \mathbb { R } ^ { n \times d _ { j } }$ denotes the feature representation at layer $j$ using $d _ { j }$ feature maps per node, the corresponding update is given by
+
+$$
+\mathbf { x } ^ { ( j + 1 ) } = \rho \left( \mathbf { x } ^ { ( j ) } \theta _ { 1 } ^ { ( j ) } + T _ { j - 1 } \mathbf { x } ^ { ( j ) } \theta _ { 2 } ^ { ( j ) } \right) ,
+$$
+
+where $\theta _ { 1 } ^ { ( j ) } , \theta _ { 2 } ^ { ( j ) }$ are $d _ { j } \times d _ { j + 1 }$ weight matrices. In this case, a simple modification of the previous theorem shows that the resulting GNN representation $\Phi _ { G } ( \mathbf { x } , \Theta )$ , $\Theta = ( \theta _ { 1 } ^ { ( j ) } , \theta _ { 2 } ^ { ( j ) } ) _ { j \le J }$ is also stable with respect to $\mathrm { d } ( G , G ^ { \prime } )$ , albeit this time the constants are parameter-dependent:
+
+Corollary 5.5. The $J$ layer GNN with parameters $\Theta = ( \theta _ { 1 } ^ { ( j ) } , \theta _ { 2 } ^ { ( j ) } ) _ { j \le J }$ satisfies
+
+$$
+\| \Phi _ { G } ( \mathbf { x } , \Theta ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } , \Theta ) \| \le \mathrm { d } ( G , G ^ { \prime } ) \frac { \| \mathbf { x } \| } { 1 - \beta } \left[ \prod _ { j \le J } ( 1 + \| \theta _ { 1 } ^ { ( j ) } \| + \| \theta _ { 2 } ^ { ( j ) } \| ) \right] ^ { 2 } .
+$$
+
+This bound is thus learning-agnostic and is proved by elementary application of the diffusion distance definition. An interesting question left for future work is to relate such stability to gradient descent optimization biases, similarly as in (Gunasekar et al., 2018; Wei et al., 2018), which could provide stability certificates for learnt GNN representations.
+
+# 6 NUMERICAL EXPERIMENTS
+
+In this section, we first show empirically the dependence of the stability result with respect to the spectral gap, and then we illustrate the discriminative power of the diffusion scattering transform in two different classification tasks; namely, the problems of authorship attribution and source localization.
+
+Consider a small-world graph $G$ with $N = 2 0 0$ nodes, edge probability $p _ { \mathsf { S W } }$ and rewiring probability $q _ { \mathrm { S W } } = 0 . 1$ . Let $\mathbf { x } \sim \mathcal { N } ( 0 , \mathbf { I } )$ be a random graph signal defined on top of $G$ and $\Phi _ { G } ( \mathbf { x } )$ the corresponding scattering transform. Let $G ^ { \prime }$ be another realization of the small-world graph, and let $\Phi _ { G ^ { \prime } } ( \mathbf { x } )$ be the scattering representation of the same graph signal $\mathbf { x }$ but on the different support $G ^ { \prime }$ . We can then proceed to compute $\left\| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \right\|$ . By changing the value of $p _ { \mathrm { { S W } } }$ we can change value of the spectral gap $\beta$ and study the dependence of the difference in representations as a function of the spectral gap. Results shown in Fig. 1a are obtained by varying $p _ { \mathsf { S W } }$ from 0.1 to 0.9. For each value of $p _ { \mathrm { { S W } } }$ we generate one graph $G$ and 50 different graphs $G ^ { \prime }$ ; and for each graph $G ^ { \prime }$ we compute $\left\| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \right\|$ for $1 , 0 0 0$ different graph signal realizations $\mathbf { x }$ . The average across all signal realizations is considered the estimate of the representation difference, and then the mean as well as the variance across all graphs are computed and shown in the figure (error bars).
+
+![](images/ab3c76d016013659ebc8bed4952003e1dc647cd2d0ff1cb9ea96f8e7921a8d8e.jpg)  
+Figure 1. (a) Difference in representation between the signal defined on the original graph $G$ and on the deformed graph $G ^ { \prime }$ as a function of the spectral gap $\beta$ . (b)-(c) Classification error percentage as a function of perturbation for the authorship attribution and the Facebook graph, respectively.
+
+Fig. 1a shows the average difference $\| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G } ( \mathbf { x } ^ { \prime } ) \|$ as a function of the spectral gap (changing $p _ { \mathsf { S W } }$ from 0.1 to 0.9 led to values of spectral gap between 0.5 and close to 1). First and foremost we observe that, indeed, as $\beta$ reaches one, the stability result gets worse and the representation difference increases. We also observe that, for deeper scattering representations, the difference also gets worse, although it is not a linear behaviour as predicted in equation 16, which suggest that the bound is not tight.
+
+For classifying we train a SVM linear model fed by features obtained from different representations. We thus compare with two non-trainable linear representations of the data: a data-based method (using the graph signals to feed the classifier) and a graph-based method (obtaining the GFT coefficients as features for the data). Additionally, we consider the graph scattering with varying depth to analyze the richness of the representation. Our aim is mainly to illustrate that the scattering representation is rich enough, relative to linear representations, and is stable to graph deformations.
+
+First, we consider the problem of authorship attribution where the main task is to determine if a given text was written by a certain author. We construct author profiles by means of word adjacency networks (WAN). This WAN acts as the underlying graph support for the graph signal representing the word count (bag-of-words) of the target text of unknown authorship. Intuitively, the choice of words of the target text should reflect the pairwise connections in the WAN, see Segarra et al. (2015) for detailed construction of WANs. In particular, we consider all works by Jane Austen. To illustrate the stability result, we construct a WAN with 188 nodes (functional words) using a varying number of texts to form the training set, obtaining an array of graphs that are similar but not exactly the same. For the test set, we include 154 excerpts by Jane Austen and 154 excerpts written by other contemporary authors, totaling 308 data points. Fig. 1b shows classification error as a function of the number of training samples used. We observe that graph scattering transforms monotonically improve while considering more training data, whereas other methods vary more erratically, showing their lack of stability (their representations vary more wildly when the underlying graph support changes). This shows that scattering diffusion transforms strike a good balance between stability and discriminative power.
+
+For the second task, let $G$ be a 234-node graph modeling real-world Facebook interactions (McAuley & Leskovec, 2012). In the source localization problem, we observe a diffusion process after some unknown time $t$ , that originated at some unknown node $i$ , i.e. we observe $\mathbf { x } = \mathbf { \bar { W } } ^ { t } \delta _ { i }$ , where $\delta _ { i }$ is the signal with all zeros except a 1 on node $i$ . The objective is to determine which community the source node $i$ belongs to. These signals can be used to model rumors that percolate through the social network by interaction between users and the objective is to determine which user group generated said rumor (or initiated a discussion on some topic). We generate a training sample of size 2, 000, for nodes $i$ chosen at random and diffusion times $t$ chosen as random as well. The GFT is computed by projecting on the eigenbasis of the operator $T$ . We note that, to avoid numerical instabilities, the diffusion is carried out using the normalized operator $( W / \lambda _ { \operatorname* { m a x } } ( W ) )$ and $t \le t _ { \mathrm { m a x } } = 2 0$ . The representation coefficients (graph signals, GFT or scattering coefficients) obtained from this set are used to train different linear SVMs to perform classification. For the test set, we draw 200 new signals. We compute the classification errors on the test set as a measure of usefulness of the obtained representations. Results are presented in Fig. 1c, where perturbations are illustrated by dropping edges with probability $p$ (adding or removing friends in Facebook). Again, it is observed that the scattering representation exhibits lower variations when the underlying graph changes, compared to the linear approaches.
+
+Finally, to remark the discriminative power of the scattering representation, we observe that as the graph scattering grows deeper, the obtained features help in more accurate classification. We remark that in regimes with sufficient labeled examples, trainable GNN architectures will generally outperform scattering-based representations.
+
+# 7 CONCLUSIONS
+
+In this work we addressed the problem of stability of graph representations. We designed a scattering transform of graph signals using diffusion wavelets and we proved that this transform is stable under deformations of the underlying graph support. More specifically, we showed that the scattering transform of a graph signal supported on two different graphs is proportional to the diffusion distance between those graphs. As a byproduct of our analysis, we obtain stability bounds for Graph Neural Networks generated by diffusion operators. Additionally, we showed that the resulting descriptions are also rich enough to be able to adequately classify plays by author in the context of authorship attribution, and identify the community origin of a signal in a source localization problem.
+
+That said, there are a number of directions to build upon from these results. First, our stability bounds depend on the spectral gap of the graph diffusion. Although lazy diffusion prevents this spectral gap to vanish, as the size of the graph increases we generally do not have a tight bound, as illustrated by regular graphs. An important direction of future research is thus to develop stability bounds which are robust to vanishing spectral gaps. Next, and related to this first point, we are working on extending the analysis to broader families of wavelet decompositions on graphs and their corresponding graph neural network versions, including stability with respect to the GromovHausdorff metric, which can be achieved by using graph wavelet filter banks that achieve bounds analogous to those in Lemmas 5.1 and 5.2.
+
+# ACKNOWLEDGMENTS
+
+Work supported by NSF CCF 1717120, US ARO W911NF1710438, ARL DCIST CRA W911NF17-2-0181, ISTC-WAS and Intel AI DevCloud.
+
+# REFERENCES
+
+J. Anden and S. Mallat. Deep scattering spectrum. ´ IEEE Trans. Signal Process., 62(16):4114–4128, Aug. 2014.   
+A. M. Bronstein, M. M. Bronstein, R. Kimmel, M. Mahmoudi, and G. Sapiro. A Gromov-Hausdorff framework with diffusion geometry for topologically-robust non-rigid shape matching. Int. J. of Comput. Vision, 89(2-3):266–286, 2010.   
+M. M. Bronstein, J. Bruna, Y. LeCun, A. Szlam, and P. Vandergheynst. Geometric deep learning: Going beyond euclidean data. IEEE Signal Process. Mag., 34(4):18–42, July 2017.   
+J. Bruna and S. Mallat. Invariant scattering convolution networks. IEEE Trans. Pattern Anal. Mach. Intell., 35(8):1872–1886, Aug. 2013.   
+J. Bruna, W. Zaremba, A. Szlam, and Y. LeCun. Spectral networks and deep locally connected networks on graphs. arXiv:1312.6203v3 [cs.LG], 21 May 2014. URL http://arxiv.org/ abs/1213.6203.   
+X. Chen, X. Cheng, and S. Mallat. Unsupervised deep Haar scattering on graphs. In Annu. Conf. Neural Inform. Process. Syst. 2014, Montreal, QC, 8-13 Dec. 2014. NIPS Foundation. ´   
+F. R. K. Chung. Spectral Graph Theory. Number 92 in Conference Board of the Mathematical Sciences: Regional Conference Series in Mathematics. American Mathematical Society, Providence, RI, 1997.   
+R. R. Coifman and S. Lafon. Diffusion maps. Appl. Comput. Harmonic Anal., 21(1):5–30, July 2006.   
+R. R. Coifman and M. Maggioni. Diffusion wavelets. Appl. Comput. Harmonic Anal., 21(1):53–94, July 2006.   
+M. Defferrard, X. Bresson, and P. Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Annu. Conf. Neural Inform. Process. Syst. 2016, Barcelona, Spain, 5-10 Dec. 2016. NIPS Foundation.   
+M. Eickenberg, G. Exarchakis, M. Hirn, and S. Mallat. Solid harmonic wavelet scattering: Predicting quantum molecular energy from invariant descriptors of 3d electronic densities. In Annu. Conf. Neural Inform. Process. Syst. 2017, Long Beach, CA, 4-9 Dec. 2017. NIPS Foundation.   
+F. Gama, A. G. Marques, G. Leus, and A. Ribeiro. Convolutional neural network architectures for signals supported on graphs. IEEE Trans. Signal Process., 67(4):1034–1049, Feb. 2019.   
+M. Gavish, B. Nadler, and R. R. Coifman. Multiscale wavelets on trees, graphs and high dimensional data: Theory and applications to semi supervised learning. In 27th Int. Conf. Mach. Learning, Haifa, Israel, 21-24 June 2010.   
+J. Gilmer, S. S. Schoenholz, P. F. Riley, O. Vinyals, and G. E. Dahl. Neural message passing for quantum chemistry. In 34th Int. Conf. Mach. Learning, Sydney, Australia, 6-11 Aug. 2017.   
+S. Gunasekar, J. Lee, D. Soudry, and N. Srebro. Characterizing implicit bias in terms of optimization geometry. In 35th Int. Conf. Mach. Learning, number 80, pp. 1832–1841, Stockholm, Sweden, 10-15 July 2018.   
+D. K. Hammond, P. Vandergheynst, and R. Gribonval. Wavelets on graphs via spectral graph theory. Appl. Comput. Harmonic Anal., 30(2):129–150, March 2011.   
+M. Henaff, J. Bruna, and Y. LeCun. Deep convolutional networks on graph-structured data. arXiv:1506.051631v1 [cs.LG], 16 June 2015. URL http://arxiv.org/abs/1506. 05163.   
+W. Huang, L. Goldsberry, N. F. Wymbs, S. T. Grafton, D. S. Bassett, and A. Ribeiro. Graph frequency analysis of brain signals. IEEE J. Select. Topics Signal Process., 10(7):1189–1203, Oct. 2016.   
+W. Huang, A. G. Marques, and A. Ribeiro. Matrix completion via graph signal processing. In 43rd IEEE Int. Conf. Acoust., Speech and Signal Process., Calgary, AB, 15-20 Apr. 2018. IEEE.   
+M. O. Jackson. Social and Economic Networks. Princeton University Press, Princeton, NJ, 2008.   
+T. N. Kipf and M. Welling. Semi-supervised classification with graph convolutional networks. In 5th Int. Conf. Learning Representations, Toulon, France, 24-26 Apr. 2017. Assoc. Comput. Linguistics.   
+I. Kostrikov, J. Bruna, D. Panozzo, and D. Zorin. Surface networks. arXiv:1705.10819v1 [stat.ML], 30 May 2017. URL http://arxiv.org/abs/1705.10819.   
+Y. LeCun, K. Kavukcuoglu, and C. Farabet. Convolutional networks and applications in vision. In 2010 IEEE Int. Symp. Circuits and Syst., Paris, France, 30 May-2 June 2010. IEEE.   
+Y. LeCun, Y. Bengio, and G. Hinton. Deep learning. Nature, 521(7553):85–117, 2015.   
+R. Levie, F. Monti, X. Bresson, and M. M. Bronstein. Cayleynets: Graph convolutional neural networks with complex rational spectral filters. IEEE Trans. Signal Process., 67(1):97–109, Jan. 2019.   
+S. Mallat. Group invariant scattering. Communications on Pure and Applied Mathematics, 65(10): 1331–1398, 2012.   
+J. McAuley and J. Leskovec. Learning to discover social circles in Ego networks. In 26th Annu. Conf. Neural Inform. Process. Syst., Stateline, TX, 3-8 Dec. 2012. NIPS Foundation.   
+B. Nadler, S. Lafon, I. Kevrekidis, and R. R. Coifman. Diffusion maps, spectral clustering and eigenfunctions of fokker-planck operators. In Annu. Conf. Neural Inform. Process. Syst. 2006, Vancouver, BC, 4-9 Dec. 2006. NIPS Foundation.   
+E. Oyallon and S. Mallat. Deep roto-translation scattering for object classification. In IEEE Comput. Soc. Conf. Comput. Vision and Pattern Recognition 2015, Boston, MA, 7-12 June 2015. IEEE Comput. Soc.   
+R. Rustamov and L. J. Guibas. Wavelets on graphs via deep learning. In Annu. Conf. Neural Inform. Process. Syst. 2013, Lake Tahoe, NV, 5-10 Dec. 2013. NIPS Foundation.   
+S. Segarra, M. Eisen, and A. Ribeiro. Authorship attribution through function word adjacency networks. IEEE Trans. Signal Process., 63(20):5464–5478, Oct. 2015.   
+L. Sifre and S. Mallat. Rotation, scaling and deformation invariant scattering for texture discrimination. In IEEE Comput. Soc. Conf. Comput. Vision and Pattern Recognition 2013, Portland, OR, 23-28 June 2013. IEEE Comput. Soc.   
+C. Wei, J. D. Lee, Q. Liu, and T. Ma. On the margin theory of feedforward neural networks. arXiv:1810.05369v1 [stat.ML], 12 Oct. 2018. URL http://arxiv.org/abs/ 1810.05369.   
+T. Wiatowski and H. Bolcskei. A mathematical theory of deep convolutional neural networks for ¨ feature extraction. IEEE Trans. Inf. Theory, 64(3):1845–1866, 2018.   
+D. Zou and G. Lerman. Graph convolutional neural networks via scattering. arXiv:1804.00099v1 [cs.IT], 31 March 2018. URL http://arxiv.org/abs/1804.00099.
+
+# A PROOF OF PROPOSITION 4.1
+
+Since all operators $\psi _ { j }$ are polynomials of the diffusion $T$ , they all diagonalise in the same basis. Let $T = V \Lambda V ^ { \mathsf { T } }$ , where $V ^ { \mathsf { T } } V = I$ contains the eigenvectors of $T$ and $\Lambda = \operatorname { d i a g } ( \lambda _ { 0 } , . . . , \lambda _ { n - 1 } )$ its eigenvalues. The frame bounds $C _ { 1 } , C _ { 2 }$ are obtained by evaluating $\| \Psi \mathbf { x } \| ^ { 2 }$ for $\mathbf x = \mathbf v _ { i }$ , $i = 1 , \ldots , n -$ 1, since $\mathbf { v } _ { 0 }$ corresponds to the square-root degree vector and $\mathbf { x }$ is by assumption orthogonal to $\mathbf { v } _ { 0 }$ .
+
+We verify that the spectrum of $\psi _ { j }$ is given by $( p _ { j } ( \lambda _ { 0 } ) , \dots , p _ { j } ( \lambda _ { n - 1 } ) )$ , where $p _ { j } ( x ) = x ^ { 2 ^ { j - 1 } } - x ^ { 2 ^ { j } }$ for $j > 0$ and $p _ { 0 } ( x ) = 1 - x$ . Denote by $\begin{array} { r } { Q _ { J } ( x ) = \sum _ { j = 0 } ^ { J - 1 } p _ { j } ( x ) ^ { 2 } } \end{array}$ . It follows from the definition that $\| \Psi \mathbf { v } _ { i } \| ^ { 2 } = Q _ { J } ( \lambda _ { i } )$ for $i = 1 , \ldots , n - 1$ and therefore
+
+$$
+C _ { 1 } = \operatorname * { m i n } _ { x \in ( 0 , \beta ) } Q _ { J } ( x ) , C _ { 2 } = \operatorname * { m a x } _ { x \in ( 0 , \beta ) } Q _ { J } ( x ) .
+$$
+
+We check that $\begin{array} { r } { C _ { 1 } \geq \operatorname* { m i n } _ { x \in ( 0 , \beta ) } p _ { 0 } ( x ) ^ { 2 } = ( 1 - \beta ) ^ { 2 } } \end{array}$ and $C _ { 2 } = Q _ { J } ( 0 ) = 1$ . Indeed, denote by $\begin{array} { r } { Q ( x ) = \sum _ { j = 0 } ^ { \infty } p _ { j } ( x ) ^ { 2 } } \end{array}$ . One easily verifies that $Q ( x )$ is continuous in $[ 0 , 1 )$ since it is bounded by a geometric series. Also, observe that $\begin{array} { r } { Q ( x ) = ( 1 - x ) ^ { 2 } + \sum _ { j > 0 } ( x ^ { 2 ^ { j - 1 } } - x ^ { 2 ^ { j } } ) ^ { 2 } } \end{array}$ satisfies the recurrence
+
+$$
+Q ( x ^ { 2 } ) = Q ( x ) + 2 x ( 1 - x ) ^ { 2 } \geq Q ( x )
+$$
+
+since $x \in [ 0 , 1 )$ . By continuity it thus follows that
+
+$$
+\operatorname* { s u p } _ { x \in [ 0 , 1 ) } Q _ { J } ( x ) \leq \operatorname* { s u p } _ { x \in [ 0 , 1 ) } Q ( x ) = \operatorname* { l i m } _ { x \to 0 } Q ( x ) = Q ( 0 ) = 1 \boxed { \Omega } .
+$$
+
+# B PROOF OF LEMMA 5.1
+
+By definition $\| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| ^ { 2 } = \| [ \Psi _ { G } - \Psi _ { G ^ { \prime } } ] ^ { * } [ \Psi _ { G } - \Psi _ { G ^ { \prime } } ] \|$ and
+
+$$
+[ \Psi _ { G } - \Psi _ { G ^ { \prime } } ] ^ { * } [ \Psi _ { G } - \Psi _ { G ^ { \prime } } ] = \sum _ { j = 0 } ^ { J _ { n } - 1 } ( \psi _ { j } ( G ) - \psi _ { j } ( G ^ { \prime } ) ) ^ { * } ( \psi _ { j } ( G ) - \psi _ { j } ( G ^ { \prime } ) ) \ : .
+$$
+
+Since $T _ { G }$ and $T _ { G ^ { \prime } }$ are self-adjoint, so are $\psi _ { j } ( G )$ and $\psi _ { j } ( G ^ { \prime } )$ . From the triangular inequality, we thus obtain
+
+$$
+\| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| ^ { 2 } \leq \sum _ { j } \| \psi _ { j } ( G ) - \psi _ { j } ( G ^ { \prime } ) \| ^ { 2 } .
+$$
+
+Denote by $\mathbf { v }$ the eigenvector associated with $\lambda _ { 0 } = 1$ , $\textstyle [ \mathbf { v } ] _ { i } = ( d _ { i } / \sum _ { j = 1 } ^ { n } d _ { j } ) ^ { 1 / 2 }$ . Since $\beta < 1$ , we can write $T = \mathbf { v } \mathbf { v } ^ { \mathsf { T } } + { \overline { { T } } }$ with $\| \overline { { T } } \| < 1$ and $\mathbf { v } \in \mathrm { N u l l } ( \overline { { T } } )$ . It follows by induction that $T ^ { r } = \mathbf { v } \mathbf { v } ^ { \mathsf { T } } + { \overline { { T } } } ^ { r }$ , and hence
+
+$$
+\psi _ { j } ( G ) = T _ { G } ^ { 2 ^ { j - 1 } } - T _ { G } ^ { 2 ^ { j } } = \overline { { { T } } } _ { G } ^ { 2 ^ { j - 1 } } - \overline { { { T } } } _ { G } ^ { 2 ^ { j } } \ ,
+$$
+
+and equivalently for $G ^ { \prime }$ , resulting in
+
+$$
+\| \psi _ { j } ( G ) - \psi _ { j } ( G ^ { \prime } ) \| ^ { 2 } \leq 2 \left( \| \overline { { T } } _ { G } ^ { 2 ^ { j - 1 } } - \overline { { T } } _ { G ^ { \prime } } ^ { 2 ^ { j - 1 } } \| ^ { 2 } + \| \overline { { T } } _ { G } ^ { 2 ^ { j } } - \overline { { T } } _ { G ^ { \prime } } ^ { 2 ^ { j } } \| ^ { 2 } \right) ,
+$$
+
+and thus
+
+$$
+\| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| ^ { 2 } \leq 4 \sum _ { j } \| \overline { { T } } _ { G } ^ { 2 ^ { j } } - \overline { { T } } _ { G ^ { \prime } } ^ { 2 ^ { j } } \| ^ { 2 } .
+$$
+
+Let us show that for matrices $A$ and $B$ such that $\beta = \operatorname* { m a x } ( \| A \| , \| B \| ) < 1$ and $r \in \mathbb { N }$ , one has
+
+$$
+\| A ^ { r } - B ^ { r } \| \leq r \beta ^ { r - 1 } \| A - B \| .
+$$
+
+Indeed, by noting $g ( t ) = ( t B + ( 1 - t ) A ) ^ { r }$ , we have
+
+$$
+\| A ^ { r } - B ^ { r } \| = \| g ( 1 ) - g ( 0 ) \| = \left\| \int _ { 0 } ^ { 1 } g ^ { \prime } ( t ) d t \right\| \leq \int _ { 0 } ^ { 1 } \| g ^ { \prime } ( t ) \| d t \leq \operatorname* { s u p } _ { t \in ( 0 , 1 ) } \| g ^ { \prime } ( t ) \| .
+$$
+
+By noting $A _ { t } = t B + ( 1 - t ) A$ we verify that
+
+$$
+g ^ { \prime } ( t ) = \sum _ { l = 0 } ^ { r - 1 } A _ { t } ^ { l } ( B - A ) A _ { t } ^ { r - l - 1 } , 
+$$
+
+which results in $\| g ^ { \prime } ( t ) \| \leq r \beta ^ { r - 1 } \| B - A \|$ , proving (23).
+
+By plugging (23) into (22) we thus obtain
+
+$$
+\begin{array} { r c l } { \| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| ^ { 2 } } & { \leq } & { 4 \| \overline { { T } } _ { G } - \overline { { T } } _ { G ^ { \prime } } \| ^ { 2 } \displaystyle \sum _ { j } 2 ^ { 2 j } \beta ^ { 2 ^ { j + 1 } } } \\ & & { \leq } & { 4 \| \overline { { T } } _ { G } - \overline { { T } } _ { G ^ { \prime } } \| ^ { 2 } \displaystyle \sum _ { t } t ^ { 2 } ( \beta ^ { 2 } ) ^ { t } } \\ & & { \leq } & { 4 \| \overline { { T } } _ { G } - \overline { { T } } _ { G ^ { \prime } } \| ^ { 2 } \displaystyle \frac { \beta ^ { 2 } ( 1 + \beta ^ { 2 } ) } { ( 1 - \beta ^ { 2 } ) ^ { 3 } } , } \end{array}
+$$
+
+which yields $\begin{array} { r } { \| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| \leq 2 \| \overline { T } _ { G } - \overline { T } _ { G ^ { \prime } } \| \sqrt { \frac { \beta ^ { 2 } ( 1 + \beta ^ { 2 } ) } { ( 1 - \beta ^ { 2 } ) ^ { 3 } } } } \end{array}$ Finally, we observe that $\| \overline { { T } } _ { G } - \overline { { T } } _ { G ^ { \prime } } \| =$ $\| T _ { G } - T _ { G ^ { \prime } } \|$ , which proves (12) as claimed. $\sqsubset$
+
+# C PROOF OF LEMMA 5.2
+
+Without loss of generality, assume that the node assignment that minimizes $\| T _ { G } - \Pi T _ { G ^ { \prime } } \Pi \| ^ { \mathsf { T } }$ is the identity. We need to bound the leading eigenvectors of two symmetric matrices $T _ { G }$ and $T _ { G ^ { \prime } }$ with a spectral gap. As before, let $T _ { G } = \mathbf { v } \mathbf { \bar { v } } ^ { \mathsf { T } } + \overline { { T } } _ { G }$ and $T _ { G ^ { \prime } } = \bar { { \bf v } ^ { \prime } } ( { \bf v } ^ { \prime } ) ^ { \sf T } + \overline { { T } } _ { G ^ { \prime } }$ . Let $\alpha = \langle { \bf v } , { \bf v } ^ { \prime } \rangle \geq 0$ since both are non-negative vectors. Denote by $E = T _ { G } - T _ { G ^ { \prime } }$ and $\overline { { { E } } } \ : = \ : \overline { { { T } } } _ { G } \ : - \ : \overline { { { T } } } _ { G ^ { \prime } }$ . Then $E = \mathbf { v } \mathbf { v } ^ { \mathsf { T } } - \mathbf { v } ^ { \prime } ( \mathbf { v } ^ { \prime } ) ^ { \mathsf { T } } + \mathbf { \overline { { E } } }$ . Hence $E \mathbf { v } = \mathbf { v } - \mathbf { v } ^ { \prime } { \overset { \cdot } { \alpha } } - { \overline { { T } } } _ { G ^ { \prime } } ( \mathbf { v } - \alpha \mathbf { v } ^ { \prime } )$ , so
+
+$$
+( { \bf I } - { \overline { { T } } } _ { G ^ { \prime } } ) ( { \bf v } - { \bf v } ^ { \prime } \alpha ) = E { \bf v }
+$$
+
+Since $\| E \| \leq \mathrm { d } ( G , G ^ { \prime } )$ and $\| \overline { { T } } _ { G ^ { \prime } } \| < \beta ^ { \prime }$ , we have
+
+$$
+( 1 - \alpha ) ( 1 - \beta ^ { \prime } ) \leq \| ( { \bf I } - \overline { { T } } _ { G ^ { \prime } } ) ( { \bf v } - { \bf v } ^ { \prime } \alpha ) \| \leq \mathrm { d } ( G , G ^ { \prime } ) ,
+$$
+
+so
+
+$$
+1 - \alpha \leq \frac { \mathrm { d } ( G , G ^ { \prime } ) } { 1 - \beta ^ { \prime } } .
+$$
+
+Finally, since $\| \mathbf { v } - \mathbf { v } ^ { \prime } \| = \sqrt { 2 - 2 \alpha }$ , we have
+
+$$
+\| \mathbf { v } - \mathbf { v } ^ { \prime } \| ^ { 2 } \leq 2 \frac { \mathrm { d } ( G , G ^ { \prime } ) } { 1 - \beta ^ { \prime } } .
+$$
+
+Since we are free to swap the role of $\mathbf { v }$ and $\mathbf { v } ^ { \prime }$ , the result follows.
+
+# D PROOF OF THEOREM 5.3
+
+First, note that $\rho _ { G } = \rho _ { G ^ { \prime } } = \rho$ since it is a pointwise nonlinearity (an absolute value), and is independent of the graph topology. Now, let’s start with $k = 0$ . In this case, we get $\| U _ { G } \mathbf { x } - U _ { G ^ { \prime } } \mathbf { x } \|$ which is immediately bounded by Lemma 5.2 satisfying equation 15.
+
+For $k = 1$ we have
+
+$$
+\begin{array} { r } { \left\| { U _ { G } \rho \Psi _ { G } \mathbf { x } - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } } \right\| = \left\| { U _ { G } \rho \Psi _ { G } \mathbf { x } - U _ { G ^ { \prime } } \rho \Psi _ { G } \mathbf { x } + U _ { G ^ { \prime } } \rho \Psi _ { G } \mathbf { x } - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } } \right\| } \\ { \leq \left\| { ( U _ { G } - U _ { G ^ { \prime } } ) \rho \Psi _ { G } \mathbf { x } } \right\| + \left\| { U _ { G ^ { \prime } } \rho ( ( \Psi _ { G } - \Psi _ { G ^ { \prime } } ) \mathbf { x } ) } \right\| } \end{array}
+$$
+
+where the triangular inequality of the norm was used, together with the fact that $\| \rho \mathbf { u } - \rho \mathbf { u } ^ { \prime } \| \leq$ $\| \rho ( \boldsymbol { \mathbf { u } } - \boldsymbol { \mathbf { u } } ^ { \prime } ) \|$ for any real vector $\mathbf { u }$ since $\rho$ is the pointwise absolute value. Using the submultiplicativity of the operator norm, we get
+
+$$
+\begin{array} { r } { \| U _ { G } \rho \Psi _ { G } \mathbf { x } - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \| \leq \| U _ { G } - U _ { G ^ { \prime } } \| \| \rho \| \| \Psi _ { G } \| \| \mathbf { x } \| + \| U _ { G ^ { \prime } } \| \| \rho \| \| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| \| \mathbf { x } \| . } \end{array}
+$$
+
+From Lemmas 5.1 and 5.2 we have that $\| \Psi _ { G } - \Psi _ { G ^ { \prime } } \| \leq \varepsilon _ { \Psi }$ and $\left\| U _ { G } - U _ { G ^ { \prime } } \right\| \le \varepsilon _ { U }$ , and from Proposition 4.1 that $\| \Psi _ { G } \| \leq 1$ . Note also that $\| U _ { G ^ { \prime } } \| = \| U _ { G } \| = 1$ and that $\| \rho \| = 1$ . This yields
+
+$$
+\left\| { U _ { G } \rho \Psi _ { G } \mathbf { x } - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } } \right\| \leq \varepsilon _ { U } \left\| { \mathbf { x } } \right\| + \varepsilon _ { \Psi } \left\| { \mathbf { x } } \right\| .
+$$
+
+satisfying equation 15 for $k = 1$ .
+
+For $k = 2$ , we observe that
+
+$$
+\begin{array} { r l } & { \left\| { U _ { G } \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf x } \right\| } \\ & { \quad = \left\| { U _ { G } \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x - U _ { G ^ { \prime } } \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x + U _ { G ^ { \prime } } \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf x } \right\| } \\ & { \quad \leq \left\| { ( U _ { G } - U _ { G ^ { \prime } } ) \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x } \right\| + \left\| { U _ { G ^ { \prime } } \left( \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x - \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf x \right) } \right\| } \end{array}
+$$
+
+The first term is bounded in a straightforward fashion by $\| ( U _ { G } - U _ { G ^ { \prime } } ) \rho \Psi _ { G } \rho \Psi _ { G } \mathbf { x } \| \leq \varepsilon _ { U } \| \mathbf { x } \|$ in analogy to the development for $k = 1$ . Since $\| U _ { G ^ { \prime } } \| = 1$ , for the second term, we focus on
+
+$$
+\left\| \rho \Psi _ { G } \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right\| = \left\| \rho \Psi _ { G } \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } + \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } - \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right\|
+$$
+
+$$
+\begin{array} { r l } { } & { { } \leq \vert \vert \rho \Psi _ { G } \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \vert \vert + \vert \vert \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } - \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \vert \vert } \end{array}
+$$
+
+We note that, in the first term in equation 33, the first layer induces an error, but after that, the processing is through the same filter banks. So we are basically interested in bounding the propagation of the error induced in the first layer. Applying twice the fact that $\| \rho ( \mathbf { u } ) - \rho ( \mathbf { u } ^ { \prime } ) \| \leq \| \rho ( \bar { \mathbf { u } } - \mathbf { u } ^ { \prime } ) \|$ we get
+
+$$
+\begin{array} { r } { \left| \left| \rho \Psi _ { G } \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right| \right| \leq \left| \left| \rho \big ( \Psi _ { G } \big ( \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G ^ { \prime } } \mathbf { x } \big ) \big ) \right| \right| \leq \left| \left| \rho \big ( \Psi _ { G } \rho \big ( \big ( \Psi _ { G } - \rho \Psi _ { G ^ { \prime } } \big ) \mathbf { x } \big ) \big ) \right| \right| . } \end{array}
+$$
+
+And following with submultiplicativity of the operator norm,
+
+$$
+\left\| \rho \Psi _ { G } \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right\| \leq \varepsilon \Psi \left\| \mathbf { x } \right\| .
+$$
+
+For the second term in equation 33, we see that the first layer applied is the same in both, namely $\rho \Psi _ { G ^ { \prime } }$ so there is no error induced. Therefore, we are interested in the error obtained after the first layer, which is precisely the same error obtained for $k = 1$ . Therefore,
+
+$$
+\begin{array} { r } { \left\| \rho \Psi _ { G } \rho \Psi _ { G ^ { \prime } } \mathbf { x } - \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right\| = \left\| \rho \Psi _ { G } \mathbf { x } - \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right\| \leq \varepsilon _ { \Psi } \left\| \mathbf { x } \right\| . } \end{array}
+$$
+
+Plugging equation 35 and equation 36 back in equation 31 we get
+
+$$
+\begin{array} { r } { \left\| { U _ { G } \rho \Psi _ { G } \rho \Psi _ { G } \mathbf x - U _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \rho \Psi _ { G ^ { \prime } } \mathbf x } \right\| \leq \varepsilon _ { U } \| \mathbf x \| + \varepsilon _ { \Psi } \| \mathbf x \| + \varepsilon _ { \Psi } \| \mathbf x \| } \end{array}
+$$
+
+satisfying equation 15 for $k = 2$ .
+
+For general $k$ we see that we will have a first term that is the error induced by the mismatch on the low pass filter that amounts to $\varepsilon _ { U }$ , a second term that accounts for the propagation through $\left( k - 1 \right)$ equal layers of an initial error, yielding $\varepsilon \Psi$ , and a final third term that is the error induced by the previous layer, $( k - 1 ) \varepsilon _ { \Psi }$ . More formally, assume that equation 15 holds for $k - 1$ , implying that
+
+$$
+\| ( \rho \Psi _ { G } ) ^ { k - 1 } \mathbf { x } - ( \rho \Psi _ { G ^ { \prime } } ) ^ { k - 1 } \mathbf { x } \| \leq ( k - 1 ) \varepsilon _ { \Psi } \| \mathbf { x } \|
+$$
+
+Then, for $k$ , we can write
+
+$$
+\begin{array} { r } { \| U _ { G } ( \rho \Psi _ { G } ) ^ { k } \mathbf { x } - U _ { G ^ { \prime } } ( \rho \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } \| \leq \| ( U _ { G } - U _ { G ^ { \prime } } ) ( \rho \Psi _ { G } ) ^ { k } \mathbf { x } \| + \| U _ { G ^ { \prime } } ( ( \rho \Psi _ { G } ) ^ { k } \mathbf { x } - ( \rho \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } ) \| } \end{array}
+$$
+
+Again, the first term we bound it in a straightforward manner using submultiplicativity of the operator norm
+
+$$
+\begin{array} { r } { \| ( U _ { G } - U _ { G ^ { \prime } } ) ( \rho \Psi _ { G } ) ^ { k } \mathbf { x } \| \leq \varepsilon _ { U } \| \mathbf { x } \| . } \end{array}
+$$
+
+For the second term, since $\| U _ { G ^ { \prime } } \| = 1$ we focus on
+
+$$
+\left| \left| \left( \rho \Psi _ { G } \right) ^ { k } \mathbf { x } - ( \rho \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } \right| \right| = \left| \left| \left( \rho \Psi _ { G } \right) ^ { k } \mathbf { x } - ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G ^ { \prime } } \mathbf { x } + ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G ^ { \prime } } \mathbf { x } - ( \rho \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } \right| \right|
+$$
+
+$$
+\begin{array} { r l } & { \leq \| ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G } \mathbf { x } - ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \| + \| ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G ^ { \prime } } \mathbf { x } - ( \rho \Psi _ { G ^ { \prime } } ) ^ { k - 1 } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \| } \end{array}
+$$
+
+The first term in equation 42 computes the propagation in the initial error caused by the first layer. Then, repeatedly applying $\| \rho ( \mathbf { u } ) - \rho ( \mathbf { u } ^ { \prime } ) \| \leq \| \rho ( \mathbf { u } - \mathbf { u } ^ { \prime } ) \|$ in analogy with $k = 2$ and using submultiplicativity, we get
+
+$$
+\left\| ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G } \mathbf { x } - ( \rho \Psi _ { G } ) ^ { k - 1 } \rho \Psi _ { G ^ { \prime } } \mathbf { x } \right\| \leq \varepsilon _ { \Psi } \| \mathbf { x } \| .
+$$
+
+The second term in equation 42 is the bounded by equation 38, since the first layer is exactly the same in this second term. Then, combining equation 43 with equation 38, yields
+
+$$
+\begin{array} { r } { \| ( \rho \Psi _ { G } ) ^ { k } \mathbf { x } - ( \rho \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } \| \leq \varepsilon _ { \Psi } + ( k - 1 ) \varepsilon _ { \Psi } \| \mathbf { x } \| = k \varepsilon _ { \Psi } \| \mathbf { x } \| . } \end{array}
+$$
+
+Overall, we get
+
+$$
+\| U _ { G } ( \rho \Psi _ { G } ) ^ { k } \mathbf { x } - U _ { G ^ { \prime } } ( \rho \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } \| \leq \varepsilon _ { U } \| \mathbf { x } \| + \varepsilon _ { \Psi } \| \mathbf { x } \|
+$$
+
+which satisfies equation 15 for $k$ . Finally, since this holds for $k = 2$ , the proof is completed by induction. $\sqsubset$
+
+# E PROOF OF COROLLARY 5.4
+
+From Theorem 5.3, we have
+
+$$
+\| U _ { G } ( \rho _ { G } \Psi _ { G } ) ^ { k } - U _ { G ^ { \prime } } ( \rho _ { G ^ { \prime } } \Psi _ { G ^ { \prime } } ) ^ { k } \| \leq \left( \frac { 2 } { 1 - \beta _ { - } } \mathrm { d } ^ { s } ( G , G ^ { \prime } ) \right) ^ { 1 / 2 } + k \sqrt { \frac { \beta _ { + } ^ { 2 } ( 1 + \beta _ { + } ^ { 2 } ) } { ( 1 - \beta _ { + } ^ { 2 } ) ^ { 3 } } } \mathrm { d } ( G , G ^ { \prime } )
+$$
+
+and, by definition (Bruna & Mallat, 2013, Sec. 3.1),
+
+$$
+\| \Phi _ { G } ( \mathbf { x } ) \| ^ { 2 } = \sum _ { k = 0 } ^ { m - 1 } \| U _ { G } ( \rho _ { G } \Psi _ { G } ) ^ { k } \mathbf { x } \| ^ { 2 }
+$$
+
+so that
+
+$$
+\| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G ^ { \prime } } ( \mathbf { x } ) \| ^ { 2 } = \sum _ { k = 0 } ^ { m - 1 } \| U _ { G } ( \rho _ { G } \Psi _ { G } ) ^ { k } \mathbf { x } - U _ { G ^ { \prime } } ( \rho _ { G ^ { \prime } } \Psi _ { G ^ { \prime } } ) ^ { k } \mathbf { x } \| ^ { 2 }
+$$
+
+Then, applying the inequality of Theorem 5.3, we get
+
+$$
+\| \Phi _ { G } - \Phi _ { G ^ { \prime } } \| ^ { 2 } \leq \sum _ { k = 0 } ^ { m - 1 } \left[ \left( \frac { 2 } { 1 - \beta _ { - } } \mathrm { d } ( G , G ^ { \prime } ) \right) ^ { 1 / 2 } + k \sqrt { \frac { \beta _ { + } ^ { 2 } ( 1 + \beta _ { + } ^ { 2 } ) } { ( 1 - \beta _ { + } ^ { 2 } ) ^ { 3 } } } \mathrm { d } ( G , G ^ { \prime } ) \right] ^ { 2 }
+$$
+
+Now, considering each term, such that
+
+$$
+\begin{array} { r l } & { \displaystyle \| \Phi _ { G } - \Phi _ { G ^ { \prime } } \| ^ { 2 } \leq \sum _ { k = 0 } ^ { m - 1 } \left( \frac { 2 } { 1 - \beta _ { - } } \mathrm { d } ( G , G ^ { \prime } ) \right) + \sum _ { k = 0 } ^ { m - 1 } k ^ { 2 } \frac { \beta _ { + } ^ { 2 } \left( 1 + \beta _ { + } ^ { 2 } \right) } { ( 1 - \beta _ { + } ^ { 2 } ) ^ { 3 } } \mathrm { d } ^ { 2 } ( G , G ^ { \prime } ) } \\ & { \qquad + \displaystyle \sum _ { k = 0 } ^ { m - 1 } 2 ^ { 3 / 2 } k \sqrt { \frac { \beta _ { + } ^ { 2 } \left( 1 + \beta _ { + } ^ { 2 } \right) } { ( 1 - \beta _ { - } ) ( 1 - \beta _ { + } ^ { 2 } ) ^ { 3 } } } \mathrm { d } ^ { 3 / 2 } ( G , G ^ { \prime } ) } \end{array}
+$$
+
+we observe that the second and third term vanish for $\mathrm { d } ( G , G ^ { \prime } ) \ll 1$ , leaving only the first term, yielding
+
+$$
+\lVert \Phi _ { G } - \Phi _ { G ^ { \prime } } \rVert ^ { 2 } \lesssim m \left( \frac { 2 } { 1 - \beta _ { - } } \mathrm { d } ( G , G ^ { \prime } ) \right) .
+$$
+
+Finally, this leads to the corollary result
+
+$$
+\| \Phi _ { G } ( \mathbf { x } ) - \Phi _ { G } ( \mathbf { x } ) \| \lesssim m ^ { 1 / 2 } \mathrm { d } ^ { 1 / 2 } ( G , G ^ { \prime } ) \| \mathbf { x } \| \mathrm { i f } d ( G , G ^ { \prime } ) \ll 1
+$$
+
+completing the proof.
+
+# F PROOF OF COROLLARY 5.5
+
+Let us denote by $e _ { j } = \| x _ { G } ^ { ( j ) } - x _ { G ^ { \prime } } ^ { ( j ) } \|$ . From (17), from the triangle inequality we verify that
+
+$$
+e _ { j + 1 } \leq a _ { j } e _ { j } + b _ { j } \mathrm { ~ , w i t h }
+$$
+
+$$
+a _ { j } = \lVert { \boldsymbol { \theta } } _ { 1 } ^ { ( j ) } \rVert + \lVert { \boldsymbol { \theta } } _ { 2 } ^ { ( j ) } \rVert , b _ { j } = \beta ^ { 2 ^ { j - 1 } } \mathrm { d } ( G , G ^ { \prime } ) \lVert { \boldsymbol { x } } _ { G ^ { \prime } } ^ { ( j ) } \rVert :
+$$
+
+It follows that
+
+$$
+e _ { J + 1 } \leq \sum _ { j \leq J } \left( \prod _ { i = j + 1 } ^ { J } a _ { i } \right) b _ { j } \leq \left( \prod _ { j = 1 } ^ { J } ( 1 + a _ { j } ) \right) \left( \sum _ { j = 1 } ^ { J } b _ { j } \right) ~ ,
+$$
+
+and since
+
+$$
+b _ { j } = \beta ^ { 2 ^ { j - 1 } } \mathrm { d } ( G , G ^ { \prime } ) \| x _ { G ^ { \prime } } ^ { ( j ) } \| \leq \beta ^ { 2 ^ { j - 1 } } \mathrm { d } ( G , G ^ { \prime } ) \| x \| \left( \prod _ { j = 1 } ^ { J } ( 1 + a _ { j } ) \right) ,
+$$
+
+we obtain
+
+$$
+e _ { J + 1 } \leq \left( \prod _ { j = 1 } ^ { J } ( 1 + a _ { j } ) \right) ^ { 2 } \mathrm { d } ( G , G ^ { \prime } ) \| x \| \sum _ { j } \beta ^ { 2 ^ { j - 1 } } \leq \left( \prod _ { j = 1 } ^ { J } ( 1 + a _ { j } ) \right) ^ { 2 } \mathrm { d } ( G , G ^ { \prime } ) \| x \| \frac { 1 } { 1 - \beta } ,
+$$
+
+as desired.

parse/train/HkNDsiC9KQ/HkNDsiC9KQ.md

@@ -0,0 +1,702 @@
+# META-LEARNING UPDATE RULES FOR UNSUPERVISED REPRESENTATION LEARNING
+
+Luke Metz   
+Google Brain   
+lmetz@google.com
+
+Niru Maheswaranathan Google Brain nirum@google.com
+
+Brian Cheung University of California, Berkeley bcheung@berkeley.edu
+
+Jascha Sohl-Dickstein Google Brain jaschasd@google.com
+
+# ABSTRACT
+
+A major goal of unsupervised learning is to discover data representations that are useful for subsequent tasks, without access to supervised labels during training. Typically, this involves minimizing a surrogate objective, such as the negative log likelihood of a generative model, with the hope that representations useful for subsequent tasks will arise as a side effect. In this work, we propose instead to directly target later desired tasks by meta-learning an unsupervised learning rule which leads to representations useful for those tasks. Specifically, we target semi-supervised classification performance, and we meta-learn an algorithm – an unsupervised weight update rule – that produces representations useful for this task. Additionally, we constrain our unsupervised update rule to a be a biologically-motivated, neuron-local function, which enables it to generalize to different neural network architectures, datasets, and data modalities. We show that the meta-learned update rule produces useful features and sometimes outperforms existing unsupervised learning techniques. We further show that the meta-learned unsupervised update rule generalizes to train networks with different widths, depths, and nonlinearities. It also generalizes to train on data with randomly permuted input dimensions and even generalizes from image datasets to a text task.
+
+# 1 INTRODUCTION
+
+Supervised learning has proven extremely effective for many problems where large amounts of labeled training data are available. There is a common hope that unsupervised learning will prove similarly powerful in situations where labels are expensive, impractical to collect, or where the prediction target is unknown during training. Unsupervised learning however has yet to fulfill this promise. One explanation for this failure is that unsupervised representation learning algorithms are typically mismatched to the target task. Ideally, learned representations should linearly expose high level attributes of data (e.g. object identity) and perform well in semi-supervised settings. Many current unsupervised objectives, however, optimize for objectives such as log-likelihood of a generative model or reconstruction error, producing useful representations only as a side effect.
+
+Unsupervised representation learning seems uniquely suited for meta-learning (Hochreiter et al., 2001; Schmidhuber, 1995). Unlike most tasks where meta-learning is applied, unsupervised learning does not define an explicit objective, which makes it impossible to phrase the task as a standard optimization problem. It is possible, however, to directly express a meta-objective that captures the quality of representations produced by an unsupervised update rule by evaluating the usefulness of the representation for candidate tasks. In this work, we propose to meta-learn an unsupervised update rule by meta-training on a meta-objective that directly optimizes the utility of the unsupervised representation. Unlike hand-designed unsupervised learning rules, this meta-objective directly targets the usefulness of a representation generated from unlabeled data for later supervised tasks.
+
+By recasting unsupervised representation learning as meta-learning, we treat the creation of the unsupervised update rule as a transfer learning problem. Instead of learning transferable features, we learn a transferable learning rule which does not require access to labels and generalizes across both data domains and neural network architectures. Although we focus on the meta-objective of semi-supervised classification here, in principle a learning rule could be optimized to generate representations for any subsequent task.
+
+# 2 RELATED WORK
+
+# 2.1 UNSUPERVISED REPRESENTATION LEARNING
+
+Unsupervised learning is a topic of broad and diverse interest. Here we briefly review several techniques that can lead to a useful latent representation of a dataset. In contrast to our work, each method imposes a manually defined training algorithm or loss function whereas we learn the algorithm that creates useful representations as determined by a meta-objective.
+
+Autoencoders (Hinton and Salakhutdinov, 2006) work by first compressing and optimizing reconstruction loss. Extensions have been made to de-noise data (Vincent et al., 2008; 2010), as well as compress information in an information theoretic way (Kingma and Welling, 2013). Le et al. (2011) further explored scaling up these unsupervised methods to large image datasets.
+
+Generative adversarial networks (Goodfellow et al., 2014) take another approach to unsupervised feature learning. Instead of a loss function, an explicit min-max optimization is defined to learn a generative model of a data distribution. Recent work has shown that this training procedure can learn unsupervised features useful for few shot learning (Radford et al., 2015; Donahue et al., 2016; Dumoulin et al., 2016).
+
+Other techniques rely on self-supervision where labels are easily generated to create a non-trivial ‘supervised’ loss. Domain knowledge of the input is often necessary to define these losses. Noroozi and Favaro (2016) use unscrambling jigsaw-like crops of an image. Techniques used by Misra et al. (2016) and Sermanet et al. (2017) rely on using temporal ordering from videos.
+
+Another approach to unsupervised learning relies on feature space design such as clustering. Coates and $\mathrm { N g }$ (2012) showed that $\mathbf { k }$ -means can be used for feature learning. Xie et al. (2016) jointly learn features and cluster assignments. Bojanowski and Joulin (2017) develop a scalable technique to cluster by predicting noise. Other techniques such as Schmidhuber (1992), Hochreiter and Schmidhuber (1999), and Olshausen and Field (1997) define various desirable properties about the latent representation of the input, such as predictability, complexity of encoding mapping, independence, or sparsity, and optimize to achieve these properties.
+
+# 2.2 META LEARNING
+
+Most meta-learning algorithms consist of two levels of learning, or ‘loops’ of computation: an inner loop, where some form of learning occurs (e.g. an optimization process), and an outer loop or metatraining loop, which optimizes some aspect of the inner loop, parameterized by meta-parameters. The performance of the inner loop computation for a given set of meta-parameters is quantified by a meta-objective. Meta-training is then the process of adjusting the meta-parameters so that the inner loop performs well on this meta-objective. Meta-learning approaches differ by the computation performed in the inner loop, the domain, the choice of meta-parameters, and the method of optimizing the outer loop.
+
+Some of the earliest work in meta-learning includes work by Schmidhuber (1987), which explores a variety of meta-learning and self-referential algorithms. Similarly to our algorithm, Bengio et al. (1990; 1992) propose to learn a neuron local learning rule, though their approach differs in task and problem formulation. Additionally, Runarsson and Jonsson (2000) meta-learn supervised learning rules which mix local and global network information. A number of papers propose meta-learning for few shot learning (Vinyals et al., 2016; Ravi and Larochelle, 2016; Mishra et al., 2017; Finn et al., 2017; Snell et al., 2017), though these do not take advantage of unlabeled data. Others make use of both labeled and unlabeld data (Ren et al., 2018). Hsu et al. (2018) uses a task created with no supervision to then train few-shot detectors. Garg (2018) use meta-learning for unsupervised learning, primarily in the context of clustering and with a small number of meta-parameters.
+
+![](images/b50ee206ceae1b452c441605a1b9b74f8d00191282dc432c22601c90d718ddeb.jpg)  
+Figure 1: Left: Schematic for meta-learning an unsupervised learning algorithm. The inner loop computation consists of iteratively applying the UnsupervisedUpdate to a base model. During metatraining the UnsupervisedUpdate (parameterized by $\theta$ ) is itself updated by gradient descent on the MetaObjective. Right: Schematic of the base model and UnsupervisedUpdate. Unlabeled input data, $x _ { 0 }$ , is passed through the base model, which is parameterised by $W$ and colored green. The goal of the UnsupervisedUpdate is to modify $W$ to achieve a top layer representation $x ^ { \overset { \triangledown } { L } }$ which performs well at few-shot learning. In order to train the base model, information is propagated backwards by the UnsupervisedUpdate in a manner analogous to backprop. Unlike in backprop however, the backward weights $V$ are decoupled from the forward weights $W$ . Additionally, unlike backprop, there is no explicit error signal as there is no loss. Instead at each layer, and for each neuron, a learning signal is injected by a meta-learned MLP parameterized by $\theta$ , with hidden state $h$ . Weight updates are again analogous to those in backprop, and depend on the hidden state of the pre- and postsynaptic neurons for each weight.
+
+To allow easy comparison against other existing approaches, we present a more extensive survey of previous work in meta-learning in table form in Table 1, highlighting differences in choice of task, structure of the meta-learning problem, choice of meta-architecture, and choice of domain.
+
+To our knowledge, we are the first meta-learning approach to tackle the problem of unsupervised representation learning, where the inner loop consists of unsupervised learning. This contrasts with transfer learning, where a neural network is instead trained on a similar dataset, and then fine tuned or otherwise post-processed on the target dataset. We additionally believe we are the first representation meta-learning approach to generalize across input data modalities as well as datasets, the first to generalize across permutation of the input dimensions, and the first to generalize across neural network architectures (e.g. layer width, network depth, activation function).
+
+# 3 MODEL DESIGN
+
+We consider a multilayer perceptron (MLP) with parameters $\phi _ { t }$ as the base model. The inner loop of our meta-learning process trains this base model via iterative application of our learned update rule. See Figure 1 for a schematic illustration and Appendix A for a more detailed diagram.
+
+In standard supervised learning, the ‘learned’ optimizer is stochastic gradient descent (SGD). A supervised loss $l \left( x , y \right)$ is associated with this model, where $x$ is a minibatch of inputs, and $y$ are the corresponding labels. The parameters $\phi _ { t }$ of the base model are then updated iteratively by performing SGD using the gradient ∂l(x,y)∂φ . This supervised update rule can be written as $\phi _ { t + 1 } = \mathsf { S }$ upervisedUpdate $( \phi _ { t } , x _ { t } , y _ { t } ; \theta )$ , where $t$ denotes the inner-loop iteration or step. Here $\theta$ are the meta-parameters of the optimizer, which consist of hyper-parameters such as learning rate and momentum.
+
+In this work, our learned update is a parametric function which does not depend on label information, $\phi _ { t + 1 } =$ UnsupervisedUpdate $( \phi _ { t } , x _ { t } ; \theta )$ . This form of the update rule is general, it encompasses many unsupervised learning algorithms and all methods in Section 2.1.
+
+In traditional learning algorithms, expert knowledge or a simple hyper-parameter search determines $\theta$ , which consists of a handful of meta-parameters such as learning rate and regularization constants. In contrast, our update rule will have orders of magnitude more meta-parameters, including the weights of a neural network. We train these meta-parameters by performing SGD on the sum of the MetaObjective over the course of (inner loop) training in order to find optimal parameters $\theta ^ { * }$ ,
+
+Table 1: A comparison of published meta-learning approaches.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>Inner loop updates</td><td rowspan=1 colspan=3>Outer loop updates, meta-parameters     objective   optimizer</td><td rowspan=1 colspan=1>Generalizes to</td></tr><tr><td rowspan=1 colspan=1>Hyper parameter optimizationJones (2001); Snoek et al. (2012);Bergstra et al. (2011); Bergstraand Bengio (2012)</td><td rowspan=1 colspan=1>many steps of optimization</td><td rowspan=1 colspan=1>optimizationhyper-parameters</td><td rowspan=1 colspan=1>training orvalidationset loss</td><td rowspan=1 colspan=1>Baysianmethods,randomsearch, etc</td><td rowspan=1 colspan=1>test data from afixed dataset</td></tr><tr><td rowspan=1 colspan=1>Neural architecture search Stanleyand Miikkulainen (2002); Zophand Le (2017); Baker et al. (2017);Zoph et al. (2018); Real et al.（2017)</td><td rowspan=1 colspan=1>supervised SGD trainingusing meta-learnedarchitecture</td><td rowspan=1 colspan=1>architecture</td><td rowspan=1 colspan=1>validationset loss</td><td rowspan=1 colspan=1>RL orevolution</td><td rowspan=1 colspan=1>test loss withinsimilar datasets</td></tr><tr><td rowspan=1 colspan=1>Task-specific optimizer (eg forquadratic function identification)(Hochreiter et al., 2001)</td><td rowspan=1 colspan=1>adjustment of model weightsby an LSTM</td><td rowspan=1 colspan=1>LSTM weights</td><td rowspan=1 colspan=1>task loss</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>similar domaintasks</td></tr><tr><td rowspan=1 colspan=1>Learned optimizers Jones (2001);Maclaurin et al. (2015);Andrychowicz et al. (2016); Chenet al. (2016); Li and Malik (2017);Wichrowska et al. (2017); Belloet al. (2017)</td><td rowspan=1 colspan=1>many steps of optimization ofa fixed loss function</td><td rowspan=1 colspan=1>parametricoptimizer</td><td rowspan=1 colspan=1>average orfinal loss</td><td rowspan=1 colspan=1>SGD orRL</td><td rowspan=1 colspan=1>new lossfunctions(mixed success)</td></tr><tr><td rowspan=1 colspan=1>Prototypical networks Snell et al.(2017)</td><td rowspan=1 colspan=1>apply a feature extractor to abatch of data and use softnearest neighbors to computeclass probabilities</td><td rowspan=1 colspan=1>weights of thefeatureextractor</td><td rowspan=1 colspan=1>few shotperformance</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>new imageclasses withinsimilar dataset</td></tr><tr><td rowspan=1 colspan=1>MAML Finn et al. (2017)</td><td rowspan=1 colspan=1>one step of SGD on trainingloss starting from ameta-learned network</td><td rowspan=1 colspan=1>initial weightsof neuralnetwork</td><td rowspan=1 colspan=1>reward ortraining loss</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>new goals,similar taskregimes withsame inputdomain</td></tr><tr><td rowspan=1 colspan=1>Evolved Policy GradientHouthooft et al. (2018)</td><td rowspan=1 colspan=1>performing gradient descenton a learned loss</td><td rowspan=1 colspan=1>parameters of alearned lossfunction</td><td rowspan=1 colspan=1>reward</td><td rowspan=1 colspan=1>EvolutionaryStrategies</td><td rowspan=1 colspan=1>newenvironmentconfigurations,both in and notin meta-trainingdistribution.</td></tr><tr><td rowspan=1 colspan=1>Few shot learning (Vinyals et al.,2016; Ravi and Larochelle, 2016;Mishra et al., 2017)</td><td rowspan=1 colspan=1>application of a recurrentmodel, e.g. LSTM, Wavenet.</td><td rowspan=1 colspan=1>recurrent modelweights</td><td rowspan=1 colspan=1>test loss ontrainingtasks</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>new imageclasses within similar dataset.</td></tr><tr><td rowspan=1 colspan=1>Meta-unsupervised learning forclustering Garg (2018)</td><td rowspan=1 colspan=1>run clustering algorithm orevaluate binary similarityfunction</td><td rowspan=1 colspan=1>clusteringalgorithm + hy-perparameters,binarysimilarityfunction</td><td rowspan=1 colspan=1>empiricalrisk mini-mization</td><td rowspan=1 colspan=1>varied</td><td rowspan=1 colspan=1>new clusteringor similaritymeasurementtasks</td></tr><tr><td rowspan=1 colspan=1>Learning synaptic learning rules(Bengio et al.,1990;1992)</td><td rowspan=1 colspan=1>run a synapse-local learningrule</td><td rowspan=1 colspan=1>parametriclearning rule</td><td rowspan=1 colspan=1>supervisedloss,or similarity tobiologically-motivatednetwork</td><td rowspan=1 colspan=1>gradientdescent, simulatedannealing,geneticalgorithms</td><td rowspan=1 colspan=1>similar domaintasks</td></tr><tr><td rowspan=1 colspan=1>Our work- metalearning forunsupervised representationlearning</td><td rowspan=1 colspan=1>many applications of an unsupervised update rule</td><td rowspan=1 colspan=1>parametricupdate rule</td><td rowspan=1 colspan=1>few shotclassifica- tion afterunsuper-visedpre-training</td><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>new basemodels (width,depth,nonlinearity),new datasets,new datamodalities</td></tr></table>
+
+$$
+\theta ^ { * } = \underset { \theta } { \operatorname { a r g m i n } } \mathbb { E } _ { \mathrm { t a s k } } \left[ \sum _ { t } \mathrm { M e t a O b j e c t i v e } ( \phi _ { t } ) \right] ,
+$$
+
+that minimize the meta-objective over a distribution of training tasks. Note that $\phi _ { t }$ is a function of $\theta$ since $\theta$ affects the optimization trajectory.
+
+In the following sections, we briefly review the main components of this model: the base model, the UnsupervisedUpdate, and the MetaObjective. See the Appendix for a complete specification. Additionally, code and meta-trained parameters $\theta$ for our meta-learned UnsupervisedUpdate is available1.
+
+# 3.1 BASE MODEL
+
+Our base model consists of a standard fully connected multi-layer perceptron (MLP), with batch normalization (Ioffe and Szegedy, 2015), and ReLU nonlinearities. We chose this as opposed to a convolutional model to limit the inductive bias of convolutions in favor of learned behavior from the UnsupervisedUpdate. We call the pre-nonlinearity activations $z ^ { 1 } , \cdots , z ^ { L }$ , and post-nonlinearity activations $x ^ { 0 } , \cdots , \overset { \cdot } { x } ^ { L }$ , where $L$ is the total number of layers, and $x ^ { 0 } \equiv x$ is the network input (raw data). The parameters are $\phi = \left\{ W ^ { 1 } , b ^ { 1 } , V ^ { 1 } , \cdot \cdot \cdot , W ^ { L } , \dot { b ^ { L } } , V ^ { L } \right\}$ , where $W ^ { l }$ and $b ^ { l }$ are the weights and biases (applied after batch norm) for layer $l$ , and $V ^ { l }$ are the corresponding weights used in the backward pass.
+
+# 3.2 LEARNED UPDATE RULE
+
+We wish for our update rule to generalize across architectures with different widths, depths, or even network topologies. To achieve this, we design our update rule to be neuron-local, so that updates are a function of pre- and post- synaptic neurons in the base model, and are defined for any base model architecture. This has the added benefit that it makes the weight updates more similar to synaptic updates in biological neurons, which depend almost exclusively on local pre- and post-synaptic neuronal activity (Whittington and Bogacz, 2017). In practice, we relax this constraint and incorporate some cross neuron information to decorrelate neurons (see Appendix G.5 for more information).
+
+To build these updates, each neuron $i$ in every layer $l$ in the base model has an MLP, referred to as an update network, associated with it, with output $h _ { b } ^ { l } i = \mathrm { M L P } \left( x _ { b } ^ { l } i , z _ { b } i ^ { l } , V ^ { l + 1 } , \delta ^ { l + 1 } ; \boldsymbol { \theta } \right)$ where $b$ indexes the training minibatch. The inputs to the MLP are the feedforward activations $( x ^ { l } \ \& \ z ^ { l } )$ defined above, and feedback weights and an error signal $V ^ { l }$ and $\delta ^ { l }$ , respectively) which are defined below.
+
+All update networks share meta-parameters $\theta$ . Evaluating the statistics of unit activation over a batch of data has proven helpful in supervised learning (Ioffe and Szegedy, 2015). It has similarly proven helpful in hand-designed unsupervised learning rules, such as sparse coding and clustering. We therefore allow $h _ { b i } ^ { l }$ to accumulate statistics across examples in each training minibatch.
+
+During an unsupervised training step, the base model is first run in a standard feed-forward fashion, populating $x _ { b i } ^ { l } , z _ { b i } ^ { l }$ . As in supervised learning, an error signal $\delta _ { b i } ^ { l }$ is then propagated backwards through the network. Unlike in supervised backprop, however, this error signal is generated by the corresponding update network for each unit. It is read out by linear projection of the per-neuron hidden state $h$ , $\delta _ { b i } ^ { \bar { l } } = \operatorname* { l i n } \left( h _ { b i } ^ { l } \right)$ , and propogated backward using a set of learned ‘backward weights’ $( V ^ { l } ) ^ { T }$ , rather than the transpose of the forward weights $( W ^ { l } ) ^ { T }$ as would be the case in backprop (diagrammed in Figure 1). This is done to be more biologically plausible (Lillicrap et al., 2016).
+
+Again as in supervised learning, the weight updates $( \Delta W ^ { l } )$ are a product of pre- and post-synaptic signals. Unlike in supervised learning however, these signals are generated using the per-neuron update networks: $\Delta W _ { i j } ^ { l } = \operatorname { f u n c } \left( h _ { b i } ^ { l } , h _ { b j } ^ { l - 1 } , W _ { i j } \right)$ . The full weight update (which involves normalization and decorrelation across neurons) is defined in Appendix G.5.
+
+# 3.3 META-OBJECTIVE
+
+The meta-objective determines the quality of the unsupervised representations. In order to meta-train via SGD, this loss must be differentiable. The meta-objective we use in this work is based on fitting a linear regression to labeled examples with a small number of data points. In order to encourage the learning of features that generalize well, we estimate the linear regression weights on one minibatch $\{ x _ { a } , y _ { a } \}$ of $K$ data points, and evaluate the classification performance on a second minibatch $\{ x _ { b } , y _ { b } \}$ also with $K$ datapoints,
+
+$$
+\hat { v } = \mathop { \mathrm { a r g m i n } } _ { v } \left( \left\| y _ { a } - v ^ { T } x _ { a } ^ { L } \right\| ^ { 2 } + \lambda \left\| v \right\| ^ { 2 } \right) , \qquad \operatorname { M e t a O b j e c t i v e } ( \cdot ; \phi ) = \operatorname { C o s D i s t } \left( y _ { b } , \hat { v } ^ { T } x _ { b } ^ { L } \right) ,
+$$
+
+where $x _ { a } ^ { L }$ , $x _ { b } ^ { L }$ are features extracted from the base model on data $x _ { a } , x _ { b }$ , respectively. The target labels $y _ { a } , y _ { b }$ consist of one hot encoded labels and potentially also regression targets from data augmentation (e.g. rotation angle, see Section 4.2). We found that using a cosine distance, CosDist, rather than unnormalized squared error improved stability. Note this meta-objective is only used during meta-training and not used when applying the learned update rule. The inner loop computation is performed without labels via the UnsupervisedUpdate.
+
+# 4 TRAINING THE UPDATE RULE
+
+# 4.1 APPROXIMATE GRADIENT BASED TRAINING
+
+We choose to meta-optimize via SGD as opposed to reinforcement learning or other black box methods, due to the superior convergence properties of SGD in high dimensions, and the high dimensional nature of $\theta$ . Training and computing derivatives through long recurrent computation of this form is notoriously difficult (Pascanu et al., 2013). To improve stability and reduce the computational cost we approximate the gradients $\frac { \partial [ \mathrm { M e t a O b j e c t i v e } ] } { \partial \theta }$ via truncated backprop through time (Shaban et al., 2018). Many additional design choices were also crucial to achieving stability and convergence in meta-learning, including the use of batch norm, and restricting the norm of the UnsupervisedUpdate update step (a full discussion of these and other choices is in Appendix B).
+
+# 4.2 META-TRAINING DISTRIBUTION AND GENERALIZATION
+
+Generalization in our learned optimizer comes from both the form of the UnsupervisedUpdate (Section 3.2), and from the meta-training distribution. Our meta-training distribution is composed of both datasets and base model architectures.
+
+We construct a set of training tasks consisting of CIFAR10 (Krizhevsky and Hinton, 2009) and multi-class classification from subsets of classes from Imagenet (Russakovsky et al., 2015) as well as from a dataset consisting of rendered fonts (Appendix H.1.1). We find that increased training dataset variation actually improves the meta-optimization process. To reduce computation we restrict the input data to 16x16 pixels or less during meta-training, and resize all datasets accordingly. For evaluation, we use MNIST (LeCun et al., 1998), Fashion MNIST (Xiao et al., 2017), IMDB (Maas et al., 2011), and a hold-out set of Imagenet classes. We additionally sample the base model architecture. We sample number of layers uniformly between 2-5 and the number of units per layer logarithmically between 64 to 512.
+
+As part of preprocessing, we permute all inputs along the feature dimension, so that the UnsupervisedUpdate must learn a permutation invariant learning rule. Unlike other work, we focus explicitly on learning a learning algorithm as opposed to the discovery of fixed feature extractors that generalize across similar tasks. This makes the learning task much harder, as the UnsupervisedUpdate has to discover the relationship between pixels based solely on their joint statistics, and cannot “cheat” and memorize pixel identity. To provide further dataset variation, we additionally augment the data with shifts, rotations, and noise. We add these augmentation coefficients as additional regression targets for the meta-objective–e.g. rotate the image and predict the rotation angle as well as the image class. For additional details, see Appendix H.1.1.
+
+# 4.3 DISTRIBUTED IMPLEMENTATION
+
+We implement the above models in distributed TensorFlow (Abadi et al., 2016). Training uses 512 workers, each of which performs a sequence of partial unrolls of the inner loop UnsupervisedUpdate, and computes gradients of the meta-objective asynchronously. Training takes ${ \sim } 8$ days, and consists of ${ \sim } 2 0 0$ thousand updates to $\theta$ with minibatch size 256. Additional details are in Appendix C.
+
+# 5 EXPERIMENTAL RESULTS
+
+First, we examine limitations of existing unsupervised and meta learning methods. Then, we show meta-training and generalization properties of our learned optimizer and finally we conclude by visualizing how our learned update rule works. For details of the experimental setup, see Appendix H.
+
+# 5.1 OBJECTIVE FUNCTION MISMATCH AND EXISTING META-LEARNING METHODS
+
+To illustrate the negative consequences of objective function mismatch in unsupervised learnin algorithms, we train a variational autoencoder on 16x16 CIFAR10. Over the course of training we evaluate classification performance from few shot classification using the learned latent representations. Training curves can be seen in Figure 2. Despite continuing to improve the VAE objective throughout training (not shown here), the classification accuracy decreases sharply later in training.
+
+To demonstrate the reduced generalization that results from learning transferable features rather than an update algorithm, we train a prototypical network (Snell et al., 2017) with and without the input shuffling described in Section 4.2. As the prototypical network primarily learns transferrable features, performance is significantly hampered by input shuffling. Results are in Figure 2.
+
+![](images/2b37ce4a17b45d805bcff92a941340738840c1956f0fa8666d739b0147ca1293.jpg)  
+Figure 2: Left: Standard unsupervised learning approaches suffer from objective function missmatch. Continuing to optimize a variational auto-encoder (VAE) hurts few-shot accuracy after some number of steps (dashed line). Right: Prototypical networks transfer features rather than a learning algorithm, and perform poorly if tasks don’t have consistent data structure. Training a prototypical network with a fully connected architecture (same as our base model) on a MiniImagenet 10-way classification task with either intact inputs (light purple) or by permuting the pixels before every training and testing task (dark purple). Performance with permuted inputs is greatly reduced (gray line). Our performance is invariant to pixel permutation.
+
+# 5.2 META-OPTIMIZATION
+
+While training, we monitor a rolling average of the meta-objective averaged across all datasets, model architectures, and the number of unrolling steps performed. In Figure 3 the training loss is continuing to decrease after 200 hours of training, which suggests that the approximate training techniques still produce effective learning. In addition to this global number, we measure performance obtained by rolling out the UnsupervisedUpdate on various meta-training and meta-testing datasets. We see that on held out image datasets, such as MNIST and Fashion Mnist, the evaluation loss is still decreasing. However, for datasets in a different domain, such as IMDB sentiment prediction (Maas et al., 2011), we start to see meta-overfitting. For all remaining experimental results, unless otherwise stated, we use meta-parameters, $\theta$ , for the UnsupervisedUpdate resulting from 200 hours of meta-training.
+
+![](images/4867ff6da60f438e88a3403959524d0dfd6002923319c6c5f60589cf00c063d5.jpg)  
+Figure 3: Training curves for the training and evaluation task distributions. Our train set consists of MiniImagenet, Alphabet, and MiniCIFAR. Our test sets are Mini Imagenet Test, Tiny Fashion MNIST, Tiny MNIST and IMDB. Error bars denote standard deviation of evaluations with a fixed window of samples evaluated from a single model. Dashed line at 200 hours indicates model used for remaining experiments unless otherwise stated. For a bigger version of this figure, see Appendix E.
+
+# 5.3 GENERALIZATION
+
+The goal of this work is to learn a general purpose unsupervised representation learning algorithm. As such, this algorithm must be able to generalize across a wide range of scenarios, including tasks that are not sampled i.i.d. from the meta-training distribution. In the following sections, we explore a subset of the factors we seek to generalize over.
+
+# Generalizing over datasets and domains
+
+In Figure 4, we compare performance on few shot classification with 10 examples per class. We evaluate test performance on holdout datasets of MNIST and Fashion MNIST at 2 resolutions: $1 4 \times 1 4$ and $2 8 \times 2 8$ (larger than any dataset experienced in meta-training). On the same base model architecture, our learned UnsupervisedUpdate leads to performance better than a variational autoencoder, supervised learning on the labeled examples, and random initialization with trained readout layer.
+
+![](images/7d4093599bb4fc9baeb1fb0b53c97b54a95613c9faf7c02ba404cfec35493ba2.jpg)  
+Figure 4: Left: The learned UnsupervisedUpdate generalizes to unseen datasets. Our learned update rule produces representations more suitable for few shot classification than those from random initialization or a variational autoecoder and outperforms fully supervised learning on the same labeled examples. Error bars show standard error. Right: Early in meta-training (purple), the UnsupervisedUpdate is able to learn useful features on a 2 way text classification data set, IMDB, despite being meta-trained only from image datasets. Later in meta-training (red) performance drops due to the domain mismatch. We show inner-loop training, consisting of $5 \mathrm { k }$ applications of the UnsupervisedUpdate evaluating the MetaObjective each iteration. Error bars show standard error across 10 runs.
+
+To further explore generalization limits, we test our learned optimizer on data from a vastly different domain. We train on a binary text classification dataset: IMDB movie reviews (Maas et al., 2011), encoded by computing a bag of words with 1K words. We evaluate using a model 30 hours and 200 hours into meta-training (see Figure 4). Despite being trained exclusively on image datasets, the 30 hour learned optimizer improves upon the random initialization by almost $10 \%$ . When meta-training for longer, however, the learned optimizer “meta-overfits” to the image domain resulting in poor performance. This performance is quite low in an absolute sense, for this task. Nevertheless, we find this result very exciting as we are unaware of any work showing this kind of transfer of learned rules from images to text.
+
+# Generalizing over network architectures
+
+We train models of varying depths and unit counts with our learned optimizer and compare results at different points in training (Figure 5). We find that despite only training on networks with 2 to 5 layers and 64 to 512 units per layer, the learned rule generalizes to 11 layers and 10,000 units per layer.
+
+![](images/0358763d92821a64c1bdbc3d7d779ffc0efaa968cf1e1bef6ea96a26b66c7bab.jpg)  
+Figure 5: Left: The learned UnsupervisedUpdate is capable of optimizing base models with hidden sizes and depths outside the meta-training regime. As we increase the number of units per layer, the learned model can make use of this additional capacity despite never having experienced it during meta-training. Right: The learned UnsupervisedUpdate generalizes across many different activation functions not seen in training. We show accuracy over the course of training on 14x14 MNIST.
+
+Next we look at generalization over different activation functions. We apply our learned optimizer on base models with a variety of different activation functions. Performance evaluated at different points in training (Figure 5). Despite training only on ReLU activations, our learned optimizer is able to improve on random initializations in all cases. For certain activations, leaky ReLU (Maas et al., 2013) and Swish (Ramachandran et al., 2017), there is little to no decrease in performance. Another interesting case is the step activation function. These activations are traditionally challenging to train as there is no useful gradient signal. Despite this, our learned UnsupervisedUpdate is capable of optimizing as it does not use base model gradients, and achieves performance double that of random initialization.
+
+# 5.4 HOW IT LEARNS AND HOW IT LEARNS TO LEARN
+
+To analyze how our learned optimizer functions, we analyze the first layer filters over the course of meta-training. Despite the permutation invariant nature of our data (enforced by shuffling input image pixels before each unsupervised training run), the base model learns features such as those shown in Figure 6, which appear template-like for MNIST, and local-feature-like for CIFAR10. Early in training, there are coarse features, and a lot of noise. As the meta-training progresses, more interesting and local features emerge.
+
+In an effort to understand what our algorithm learns to do, we fed it data from the two moons dataset. We find that despite being a 2D dataset, dissimilar from the image datasets used in meta-training, the learned model is still capable of manipulating and partially separating the data manifold in a purely unsupervised manner (Figure 6). We also find that almost all the variance in the embedding space is dominated by a few dimensions. As a comparison, we do the same analysis on MNIST. In this setting, the explained variance is spread out over more of the principal components. This makes sense as the generative process contains many more latent dimensions – at least enough to express the 10 digits.
+
+![](images/8873921da0c28140ef3833c2aa553707914e06a20424f2ffafda085c0db008b4.jpg)  
+Figure 6: Left: From left to right we show first layer base model receptive fields produced by our learned UnsupervisedUpdate rule over the course of meta-training. Each pane consists of first layer filters extracted from $\phi$ after $1 0 \mathrm { k }$ applications of UnsupervisedUpdate on MNIST (top) and CIFAR10 (bottom). For MNIST, the optimizer learns image-template-like features. For CIFAR10, low frequency features evolve into higher frequency and more spatially localized features. For more filters, see Appendix D. Center: Visualization of learned representations before (left) and after (right) training a base model with our learned UnsupervisedUpdate for two moons (top) and MNIST (bottom). The UnsupervisedUpdate is capable of manipulating the data manifold, without access to labels, to separate the data classes. Visualization shows a projection of the 32-dimensional representation of the base network onto the top three principal components. Right: Cumulative variance explained using principal components analysis (PCA) on the learned representations. The representation for two moons data (red) is much lower dimensional than MNIST (blue), although both occupy a fraction of the full 32-dimensional space.
+
+# 6 DISCUSSION
+
+In this work we meta-learn an unsupervised representation learning update rule. We show performance that matches or exceeds existing unsupervised learning on held out tasks. Additionally, the update rule can train models of varying widths, depths, and activation functions. More broadly, we demonstrate an application of meta-learning for learning complex optimization tasks where no objective is explicitly defined. Analogously to how increased data and compute have powered supervised learning, we believe this work is a proof of principle that the same can be done with algorithm design–replacing hand designed techniques with architectures designed for learning and learned from data via metalearning.
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Samy Bengio, David Dohan, Keren Gu, Gamaleldin Elsayed, C. Daniel Freeman, Sam Greydanus, Nando de Freitas, Ross Goroshin, Ishaan Gulrajani, Eric Jang, Hugo Larochelle, Jeremy Nixon, Esteban Real, Suharsh Sivakumar, Pavel Sountsov, Alex Toshev, George Tucker, Hoang Trieu Trinh, Olga Wichrowska, Lechao Xiao, Zongheng Yang, Jiaqi Zhai and the rest of the Google Brain team for extremely helpful conversations and feedback on this work.
+
+# REFERENCES
+
+Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pages 87–94. Springer, 2001.
+
+Juergen Schmidhuber. On learning how to learn learning strategies. 1995.
+
+Geoffrey E Hinton and Ruslan R Salakhutdinov. Reducing the dimensionality of data with neural networks. science, 313(5786):504–507, 2006.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Proceedings of the 25th international conference on Machine learning, pages 1096–1103. ACM, 2008.
+
+Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of Machine Learning Research, 11(Dec):3371–3408, 2010.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Quoc V Le, Marc’Aurelio Ranzato, Rajat Monga, Matthieu Devin, Kai Chen, Greg S Corrado, Jeff Dean, and Andrew Y Ng. Building high-level features using large scale unsupervised learning. arXiv preprint arXiv:1112.6209, 2011.
+
+Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural information processing systems, pages 2672–2680, 2014.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks. arXiv preprint arXiv:1511.06434, 2015.
+
+Jeff Donahue, Philipp Krähenbühl, and Trevor Darrell. Adversarial feature learning. arXiv preprint arXiv:1605.09782, 2016.
+
+Vincent Dumoulin, Ishmael Belghazi, Ben Poole, Alex Lamb, Martin Arjovsky, Olivier Mastropietro, and Aaron Courville. Adversarially learned inference. arXiv preprint arXiv:1606.00704, 2016.
+
+Mehdi Noroozi and Paolo Favaro. Unsupervised learning of visual representations by solving jigsaw puzzles. In European Conference on Computer Vision, pages 69–84. Springer, 2016.
+
+Ishan Misra, C Lawrence Zitnick, and Martial Hebert. Shuffle and learn: unsupervised learning using temporal order verification. In European Conference on Computer Vision, pages 527–544. Springer, 2016.
+
+Pierre Sermanet, Corey Lynch, Jasmine Hsu, and Sergey Levine. Time-contrastive networks: Self-supervised learning from multi-view observation. arXiv preprint arXiv:1704.06888, 2017.
+
+Adam Coates and Andrew Y Ng. Learning feature representations with k-means. In Neural networks: Tricks of the trade, pages 561–580. Springer, 2012.
+
+Junyuan Xie, Ross Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In International conference on machine learning, pages 478–487, 2016.
+
+Piotr Bojanowski and Armand Joulin. Unsupervised learning by predicting noise. arXiv preprint arXiv:1704.05310, 2017.
+
+Jürgen Schmidhuber. Learning factorial codes by predictability minimization. Neural Computation, 4(6): 863–879, 1992.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Feature extraction through lococode. Neural Computation, 11(3): 679–714, 1999.
+
+Bruno A Olshausen and David J Field. Sparse coding with an overcomplete basis set: A strategy employed by v1? Vision research, 37(23):3311–3325, 1997.
+
+Jürgen Schmidhuber. Evolutionary principles in self-referential learning, or on learning how to learn: the meta-meta-... hook. PhD thesis, Technische Universität München, 1987.
+
+Yoshua Bengio, Samy Bengio, and Jocelyn Cloutier. Learning a synaptic learning rule. Université de Montréal, Département d’informatique et de recherche opérationnelle, 1990.
+
+Samy Bengio, Yoshua Bengio, Jocelyn Cloutier, and Jan Gecsei. On the optimization of a synaptic learning rule. In Preprints Conf. Optimality in Artificial and Biological Neural Networks, pages 6–8. Univ. of Texas, 1992.
+
+Thomas Philip Runarsson and Magnus Thor Jonsson. Evolution and design of distributed learning rules. In Combinations of Evolutionary Computation and Neural Networks, 2000 IEEE Symposium on, pages 59–63. IEEE, 2000.
+
+Oriol Vinyals, Charles Blundell, Tim Lillicrap, koray kavukcuoglu, and Daan Wierstra. Matching networks for one shot learning. In D. D. Lee, M. Sugiyama, U. V. Luxburg, I. Guyon, and R. Garnett, editors, Advances in Neural Information Processing Systems 29, pages 3630–3638. Curran Associates, Inc., 2016. URL http:// papers.nips.cc/paper/6385-matching-networks-for-one-shot-learning.pdf.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. International Conference on Learning Representations, 2016.
+
+Nikhil Mishra, Mostafa Rohaninejad, Xi Chen, and Pieter Abbeel. Meta-learning with temporal convolutions. arXiv preprint arXiv:1707.03141, 2017.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Doina Precup and Yee Whye Teh, editors, Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pages 1126–1135, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR. URL http://proceedings.mlr. press/v70/finn17a.html.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in Neural Information Processing Systems, pages 4080–4090, 2017.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. arXiv preprint arXiv:1803.00676, 2018.
+
+Kyle Hsu, Sergey Levine, and Chelsea Finn. Unsupervised learning via meta-learning. arXiv preprint arXiv:1810.02334, 2018.
+
+Vikas Garg. Supervising unsupervised learning. In Advances in Neural Information Processing Systems, pages 4996–5006, 2018.
+
+Donald R Jones. A taxonomy of global optimization methods based on response surfaces. Journal of global optimization, 21(4):345–383, 2001.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pages 2951–2959, 2012.
+
+James S Bergstra, Rémi Bardenet, Yoshua Bengio, and Balázs Kégl. Algorithms for hyper-parameter optimization. In Advances in neural information processing systems, pages 2546–2554, 2011.
+
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012.
+
+Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. International Conference on Learning Representations, 2017. URL https://arxiv.org/abs/1611.01578.
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik, and Ramesh Raskar. Designing neural network architectures using reinforcement learning. International Conference on Learning Representations, 2017.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V Le. Learning transferable architectures for scalable image recognition. Proceedings of the IEEE conference on computer vision and pattern recognition, 2018.
+
+Esteban Real, Sherry Moore, Andrew Selle, Saurabh Saxena, Yutaka Leon Suematsu, Quoc Le, and Alex Kurakin. Large-scale evolution of image classifiers. arXiv preprint arXiv:1703.01041, 2017.
+
+Dougal Maclaurin, David Duvenaud, and Ryan Adams. Gradient-based hyperparameter optimization through reversible learning. In International Conference on Machine Learning, pages 2113–2122, 2015.
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. In Advances in Neural Information Processing Systems, pages 3981–3989, 2016.
+
+Yutian Chen, Matthew W Hoffman, Sergio Gómez Colmenarejo, Misha Denil, Timothy P Lillicrap, Matt Botvinick, and Nando de Freitas. Learning to learn without gradient descent by gradient descent. arXiv preprint arXiv:1611.03824, 2016.
+
+Ke Li and Jitendra Malik. Learning to optimize. International Conference on Learning Representations, 2017.
+
+Olga Wichrowska, Niru Maheswaranathan, Matthew W Hoffman, Sergio Gomez Colmenarejo, Misha Denil, Nando de Freitas, and Jascha Sohl-Dickstein. Learned optimizers that scale and generalize. International Conference on Machine Learning, 2017.
+
+Irwan Bello, Barret Zoph, Vijay Vasudevan, and Quoc Le. Neural optimizer search with reinforcement learning. 2017. URL https://arxiv.org/pdf/1709.07417.pdf.
+
+Rein Houthooft, Richard Y Chen, Phillip Isola, Bradly C Stadie, Filip Wolski, Jonathan Ho, and Pieter Abbeel. Evolved policy gradients. arXiv preprint arXiv:1802.04821, 2018.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In Francis Bach and David Blei, editors, Proceedings of the 32nd International Conference on Machine Learning, volume 37 of Proceedings of Machine Learning Research, pages 448–456, Lille, France, 07–09 Jul 2015. PMLR. URL http://proceedings.mlr.press/v37/ioffe15. html.
+
+James CR Whittington and Rafal Bogacz. An approximation of the error backpropagation algorithm in a predictive coding network with local hebbian synaptic plasticity. Neural computation, 29(5):1229–1262, 2017.
+
+Timothy P Lillicrap, Daniel Cownden, Douglas B Tweed, and Colin J Akerman. Random synaptic feedback weights support error backpropagation for deep learning. Nature communications, 7:13276, 2016.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural networks. In International Conference on Machine Learning, pages 1310–1318, 2013.
+
+Amirreza Shaban, Ching-An Cheng, Nathan Hatch, and Byron Boots. Truncated back-propagation for bilevel optimization. arXiv preprint arXiv:1810.10667, 2018.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, Alexander C. Berg, and Li Fei-Fei. ImageNet Large Scale Visual Recognition Challenge. International Journal of Computer Vision (IJCV), 115(3):211–252, 2015. doi: 10.1007/s11263-015-0816-y.
+
+Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
+
+Han Xiao, Kashif Rasul, and Roland Vollgraf. Fashion-mnist: a novel image dataset for benchmarking machine learning algorithms, 2017.
+
+Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies, pages 142–150, Portland, Oregon, USA, June 2011. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/ P11-1015.
+
+Martín Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. Tensorflow: A system for large-scale machine learning. In OSDI, volume 16, pages 265–283, 2016.
+
+Andrew L Maas, Awni Y Hannun, and Andrew Y Ng. Rectifier nonlinearities improve neural network acoustic models. In Proc. icml, volume 30, page 3, 2013.
+
+Prajit Ramachandran, Barret Zoph, and Quoc Le. Searching for activation functions. 2017.
+
+Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. Understanding the exploding gradient problem. CoRR, abs/1211.5063, 2012.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Alex Graves, Ioannis Antonoglou, Daan Wierstra, and Martin Riedmiller. Playing atari with deep reinforcement learning. arXiv preprint arXiv:1312.5602, 2013.
+
+Barak Pearlmutter. An investigation of the gradient descent process in neural networks. PhD thesis, Carnegie Mellon University Pittsburgh, PA, 1996.
+
+Samuel S Schoenholz, Justin Gilmer, Surya Ganguli, and Jascha Sohl-Dickstein. Deep information propagation. arXiv preprint arXiv:1611.01232, 2016.
+
+# A MORE DETAILED SYSTEM DIAGRAM
+
+![](images/8ea1ecceab9cf8adc41c04d35a7ac8cf9a24672d8a07be0bc27843a805858ca3.jpg)  
+Figure App.1: Schematic for meta-learning an unsupervised learning algorithm. We show the hierarchical nature of both the meta-training procedure and update rule. a) Meta-training, where the meta-parameters, $\theta$ , are updated via our meta-optimizer (SGD). b) The gradients of the MetaObjective with respect to $\theta$ are computed by backpropagation through the unrolled application of the UnsupervisedUpdate. c) UnsupervisedUpdate updates the base model parameters $( \phi )$ using a minibatch of unlabeled data. d) Each application of UnsupervisedUpdate involves computing a forward and “backward” pass through the base model. The base model itself is a fully connected network producing hidden states $x ^ { l }$ for each layer $l$ . The “backward” pass through the base model uses an error signal from the layer above, $\delta$ , which is generated by a meta-learned function. e.) The weight updates $\Delta \phi$ are computed using a convolutional network, using $\delta$ and $x$ from the pre- and post-synaptic neurons, along with several other terms discussed in the text.
+
+# B STABILIZING GRADIENT BASED META-LEARNING TRAINING
+
+Training and computing derivatives through recurrent computation of this form is notoriously difficult Pascanu et al. (2013). Training parameters of recurrent systems in general can lead to chaos. We used the usual techniques such as gradient clipping (Pascanu et al., 2012), small learning rates, and adaptive learning rate methods (in our case Adam (Kingma and Ba, 2014)), but in practice this was not enough to train most UnsupervisedUpdate architectures. In this section we address other techniques needed for stable convergence.
+
+When training with truncated backprop the problem shifts from pure optimization to something more like optimizing on a Markov Decision Process where the state space is the base-model weights, $\phi$ , and the ‘policy’ is the learned optimizer. While traversing these states, the policy is constantly meta-optimized and changing, thus changing the distribution of states the optimizer reaches. This type of non-i.i.d training has been discussed at great length with respect to on and off-policy RL training algorithms (Mnih et al., 2013). Other works cast optimizer meta-learning as RL (Li and Malik, 2017) for this very reason, at a large cost in terms of gradient variance. In this work, we partially address this issue by training a large number of workers in parallel, to always maintain a diverse set of states when computing gradients.
+
+For similar reasons, the number of steps per truncation, and the total number of unsupervised training steps, are both sampled in an attempt to limit the bias introduced by truncation.
+
+We found restricting the maximum inner loop step size to be crucial for stability. Pearlmutter (1996) studied the effect of learning rates with respect to the stability of optimization and showed that as the learning rate increases gradients become chaotic. This effect was later demonstrated with respect to neural network training in Maclaurin et al. (2015). If learning rates are not constrained, we found that they rapidly grew and entered this chaotic regime.
+
+Another technique we found useful in addressing these problems is the use of batch norm in both the base model and in the UnsupervisedUpdate rule. Multi-layer perceptron training traditionally requires very precise weight initialization for learning to occur. Poorly scaled initialization can make learning impossible (Schoenholz et al., 2016). When applying a learned optimizer, especially early in meta-training of the learned optimizer, it is very easy for the learned optimizer to cause high variance weights in the base model, after which recovery is difficult. Batch norm helps solve this issues by making more of the weight space usable.
+
+# C DISTRIBUTED IMPLEMENTATION
+
+We implement the described models in distributed Tensorflow (Abadi et al., 2016). We construct a cluster of 512 workers, each of which computes gradients of the meta-objective asynchronously. Each worker trains on one task by first sampling a dataset, architecture, and a number of training steps. Next, each worker samples $k$ unrolling steps, does $k$ applications of the UnsupervisedUpdate $( \cdot ; \theta )$ , computes the MetaObjective on each new state, computes $\frac { \partial [ \mathrm { M e t a O b j e c t i v e } ] } { \partial \theta }$ and sends this gradient to a parameter server. The final base-model state, $\phi$ , is then used as the starting point for the next unroll until the specified number of steps is reached. These gradients from different workers are batched and $\theta$ is updated with asynchronous SGD. By batching gradients as workers complete unrolls, we eliminate most gradient staleness while retaining the compute efficiency of asynchronous workers, especially given heterogeneous workloads which arise from dataset and model size variation. An overview of our training can be seen in algorithm F. Due to the small base models and the sequential nature of our compute workloads, we use multi core CPUs as opposed to GPUs. Training occurs over the course of ${ \sim } 8$ days with ${ \sim } 2 0 0$ thousand updates to $\theta$ with minibatch size 256.
+
+# D MORE FILTERS OVER META-TRAINING
+
+![](images/6c675c6e5ca107e5dc5da59233b00e68ebbf7517c641a5ce1cb7c1b8dd9acded.jpg)  
+Figure App.2: More filters extracted over the course of meta-training. Note, due to implementation reasons, the columns do not represent the same point / same iteration of $\theta$ . Each filter is extracted after 10k inner loop optimization steps, at $\phi _ { 1 0 k }$ . From top to bottom we show: MNIST, Tiny MNIST, Alphabet, CIFAR10, and Mini CIFAR10. Filters shift from noise at initialization to more local features later in meta-training.
+
+![](images/3d06b921126814b10830d2cac494666ceed453bf1c3ee4ef9ec50fb7d704861a.jpg)  
+Figure App.3: Training curves for the meta-training and meta-evaluation task distributions. Our meta-train set consists of Mini Imagenet, Alphabet, and MiniCIFAR10. Our meta-test sets are Mini Imagenet Test, Tiny Fashion MNIST, Tiny MNIST and IMDB. Error bars denote standard deviation of evaluations with a fixed window of samples evaluated from a single model.
+
+# F LEARNING ALGORITHM
+
+Initialize UnsupervisedUpdates parameters, $\theta _ { 0 }$ .   
+Initialize meta-training step count $v  0$ .   
+Initialize shared gradient state $s$   
+Initialize $R$ to be max meta-training steps.   
+while $r < R$ on 512 workers in parallel do Sample supervised task, $\mathcal { D }$ Sample base model $f ( \cdot ; \phi )$ and initialize $\phi _ { 0 }$ randomly Sample $K$ truncated iterations Initialize learner iteration count: $t \gets 0$ for $k = 1$ to $K$ do Sample $U$ unroll iterations for $u = 0$ to $U$ do Sample data, $x$ , from $\mathcal { D }$ $\partial _ { t + u + 1 } = \mathrm { U n s u p e r v i s e d U p d a t e } ( x , \phi _ { t + u } ; \theta _ { r } )$ end for Initialize MetaObjective accumulator $J \gets 0$ for $u = 1$ to $U$ do for $m = 1$ to $M$ (number of MetaObjective evaluations per iteration) do Sample 2 batches of data, $_ { x , x ^ { \prime } }$ , and labels, $y , y ^ { \prime }$ from $\mathcal { D }$ for both training and testing. $\begin{array} { r } { J = \stackrel { \bullet } { J } + \frac { 1 } { U M } } \end{array}$ MetaObjective $( x , y , x ^ { \prime } , y ^ { \prime } , \phi _ { t + u } )$ end for end for Compute $\frac { \partial J } { \partial \theta _ { r } }$ for the last $U$ steps and store in $s$ Update current unroll iteration: $t  t + U$ if size of $s >$ meta-batch-size then Take averaged batch of gradients $G$ from $s$ $\begin{array} { r l } & { \theta _ { r + 1 } = \theta _ { r } - \mathrm { A d a m U p } \mathbf { \breve { d a t e } } ( G ) } \\ & { r  r + 1 } \end{array}$ end if end for   
+end while
+
+# G MODEL SPECIFICATION
+
+In this section we describe the details of our base model and learned optimizer. First, we describe the inner loop, and then we describe the meta-training procedure in more depth.
+
+In the following sections, $\lambda _ { n a m e }$ denotes a hyper-parameter for the learned update rule.
+
+The design goals of this system are stated in the text body. At the time of writing, we were unaware of any similar systems, so as such the space of possible architectures was massive. Future work consists of simplifying and improving abstractions around algorithmic components.
+
+An open source implementation of the UnsupervisedUpdate can be found at https: //github.com/tensorflow/models/tree/master/research/learning_ unsupervised_learning.
+
+# G.1 INNER LOOP
+
+The inner loop computation consists of iterative application of the UnsupervisedUpdate on a Base Model parameterized by $\phi$ ,
+
+$$
+\phi _ { t + 1 } = \mathrm { U n s u p e r v i s e d U p d a t e } ( \cdot , \phi _ { t } ; \theta ) ,
+$$
+
+where $\phi$ consists of forward weights, $W ^ { l }$ , biases, $b ^ { l }$ , parameterizing a multi-layer perceptron as well as backward weights, $V ^ { l }$ used by UnsupervisedUpdate when inner-loop training.
+
+This computation can be broken down further as a forward pass on an unlabeled batch of data,
+
+$$
+x ^ { 0 } \sim \mathcal { D }
+$$
+
+$$
+\{ x ^ { 1 } . . x ^ { L } , z ^ { 1 } . . z ^ { L } \} = f ( x ^ { 0 } ; \phi _ { t } ) ,
+$$
+
+where $z ^ { l }$ , and $x ^ { l }$ are the pre- and post-activations on layer $l$ , and $x ^ { 0 }$ is input data. We then compute weight updates:
+
+$$
+\{ ( \Delta W ^ { 1 \cdots L } ) _ { t } , ( \Delta b ^ { 1 \cdots L } ) _ { t } , ( \Delta V ^ { 1 \cdots L } ) _ { t } \} = \mathrm { C o m p u t e D e l t a W e i g h t } ( x ^ { 0 } \cdot \cdot x ^ { L } , z ^ { 1 } \cdot \cdot \cdot z ^ { L } , \phi _ { t } ; \theta ) _ { i } ,
+$$
+
+Finally, the next set of $\phi$ forward weights $( W ^ { l } )$ , biases $( b ^ { l } )$ , and backward weights $( V ^ { l } )$ , are computed. We use an SGD like update but with the addition of a decay term. Equivalently, this can be seen as setting the weights and biases to an exponential moving average of the $\Delta W ^ { l } , \dot { \Delta } V ^ { l }$ , and $\Delta b ^ { l }$ terms.
+
+$$
+\begin{array} { r l } & { W _ { t + 1 } ^ { l } = W _ { t } ^ { l } ( 1 - \lambda _ { \phi l r } ) + \Delta W ^ { l } \lambda _ { \phi l r } } \\ & { V _ { t + 1 } ^ { l } = V _ { t } ^ { l } ( 1 - \lambda _ { \phi l r } ) + \Delta V ^ { l } \lambda _ { \phi l r } } \\ & { b _ { t + 1 } ^ { l } = b _ { t } ^ { l } ( 1 - \lambda _ { \phi l r } ) + \Delta b ^ { l } \lambda _ { \phi l r } } \end{array}
+$$
+
+We use $\lambda _ { \phi l r } = 3 e - 4$ in our work. $\Delta W ^ { l } , \Delta V ^ { l } , \Delta b ^ { l }$ are computed via meta-learned functions (parameterized by $\theta$ ).
+
+In the following sections, we describe the functional form of the base model, $f$ , as well as the functional form of ComputeDeltaWeight $( \cdot ; \theta )$ .
+
+# G.2 BASE MODEL
+
+The base model, the model our learned update rule is training, is an $L$ layer multi layer perception with batch norm. We define $\phi$ as this model’s parameters, consisting of weights $( \hat W ^ { l } )$ and biases $( b ^ { l } )$ as well as the backward weights $( V ^ { l } )$ used only during inner-loop training (applications of UnsupervisedUpdate). We define $\bar { N } ^ { 1 } . . N ^ { L }$ to be the sizes of the layers of the base model and $N ^ { 0 }$ to be the size of the input data.
+
+$$
+\phi = \{ W ^ { 1 } . . W ^ { L } , V ^ { 1 } . . V ^ { L } , b ^ { 1 } . . b ^ { L } \} ,
+$$
+
+where
+
+$$
+\begin{array} { c } { { W ^ { l } \in \mathbb R ^ { N ^ { l - 1 } , N ^ { l } } } } \\ { { V ^ { l } \in \mathbb R ^ { N ^ { l - 1 } , N ^ { l } } } } \\ { { b ^ { l } \in \mathbb R ^ { N ^ { l } } } } \end{array}
+$$
+
+where $N ^ { l }$ is the hidden size of the network, $N ^ { 0 }$ is the input size of data, and $N ^ { L }$ is the size of the output embedding. In this work, we fix the output layer: $N ^ { L } = 3 2$ and vary the remaining the intermediate $N ^ { 1 . . \bar { ( } L - 1 ) }$ hidden sizes.
+
+The forward computation parameterized by $\phi$ , consumes batches of unlabeled data from a dataset $\mathcal { D }$
+
+$$
+\begin{array} { r l } & { x ^ { 0 } \sim \mathcal { D } , x ^ { 0 } \in \mathbb { R } ^ { B , N ^ { 0 } } } \\ & { z ^ { l } = \mathrm { B a t c h N o r m } \left( x ^ { l - 1 } W ^ { l } \right) + b ^ { l } } \\ & { x ^ { l } = \mathrm { R e L U } ( { \mathrm { z } } ^ { 1 } ) } \end{array}
+$$
+
+for $l = 1 . . L$ .
+
+We define $f ( x ; \phi )$ as a function that returns the set of internal pre- and post-activation function hidden states as well as ${ \hat { f } } ( x ; \phi )$ as the function returning the final hidden state:
+
+$$
+\begin{array} { l } { { f ( x , \phi ) = \{ z ^ { 1 } . . . z ^ { L } , x ^ { 0 } . . . x ^ { L } , \phi \} } } \\ { { \hat { f } ( x , \phi ) = x ^ { L } } } \end{array}
+$$
+
+# G.3 METAOBJECTIVE
+
+We define the MetaObjective to be a few shot linear regression. To increase stability and avoid undesirable loss landscapes, we additionally center, as well as normalize the predicted target before doing the loss computation. The full computation is as follows:
+
+MetaObjective(x, y, x0, y0, φ) :: (RB,N 0 , RB,N classes , $\begin{array} { r } { \left. ( x , y , x ^ { \prime } , y ^ { \prime } , \phi ) : \boldsymbol { : } ( \mathbb { R } ^ { B , N ^ { 0 } } , \mathbb { R } ^ { B , N ^ { c l a s s e s } } , \mathbb { R } ^ { B , N ^ { 0 } } , \mathbb { R } ^ { B , N ^ { c l a s s e s } } , \Phi ) \right. \mathbb { R } ^ { 1 } , } \end{array}$ (A where $N ^ { c l a s s e s }$ is the number of classes, and $y , y ^ { \prime }$ are one hot encoded labels.
+
+First, the inputs are converted to embeddings with the base model,
+
+$$
+x ^ { L } = \hat { f } ( x ; \phi )
+$$
+
+$$
+\boldsymbol { x } ^ { \prime L } = \boldsymbol { \hat { f } } ( \boldsymbol { x } ^ { \prime } ; \boldsymbol { \phi } )
+$$
+
+Next, we center and normalize the prediction targets. We show this for $y$ , but $y ^ { \prime }$ is processed identically.
+
+$$
+\begin{array} { c c c } { \displaystyle \bar { y } = \frac { 1 } { B N ^ { c l a s s e s } } \sum _ { i } ^ { B } { \sum _ { j } ^ { c l a s s e s } y _ { i j } } } \\ { \displaystyle \hat { y } _ { i j } = \frac { y _ { i j } - \bar { y } } { \sqrt { \frac { 1 } { N ^ { c l a s s e s } } \sum _ { a } ^ { N ^ { c l a s s e s } } { \left\| \bar { y } _ { i a } \right\| _ { 2 } ^ { 2 } } } } } \end{array}
+$$
+
+We then solve for the linear regression weights in closed form with features: $x ^ { L }$ and targets: $\hat { y }$ . We account for a bias by concatenating a $1$ ’s vector to the features.
+
+$$
+\begin{array} { l } { A = [ x ^ { L } ; \mathbb { 1 } ] } \\ { C = \left( ( A ^ { t } A ) + I \lambda _ { \mathrm { r i d g e } } \right) ^ { - 1 } A ^ { T } \hat { y } } \end{array}
+$$
+
+We then use these inferred regression weights $C$ to make a prediction on the second batch of data, normalize the resulting prediction, and compute a final loss,
+
+$$
+\begin{array} { c } { \displaystyle p = C [ { \boldsymbol { x } ^ { \prime } } ^ { L } ; \mathbb { 1 } ] } \\ { \displaystyle \hat { p } _ { b i } = \frac { p _ { b i } } { \left\| p _ { b } \right\| _ { 2 } } } \\ { \displaystyle \mathrm { M e t a O b j e c t i v e ( \cdot ) } = \frac { 1 } { B } \sum _ { b } ^ { B } \left\| \hat { p } _ { b } - \hat { y } _ { b } \right\| _ { 2 } ^ { 2 } . } \end{array}
+$$
+
+Note that due to the normalization of predictions and targets, this corresponds to a cosine distance (up to an offset and multiplicative factor).
+
+# G.4 UNSUPERVISEDUPDATE
+
+The learned update rule is parameterized by $\theta$ . In the following section, we denote all instances of $\theta$ with a subscript to be separate named learnable parameters of the UnsupervisedUpdate. $\theta$ is shared across all instantiations of the unsupervised learning rule (shared across layers). It is this weight sharing that lets us generalize across different network architectures.
+
+The computation is split into a few main components: first, there is the forward pass, defined in $f ( x ; \phi )$ . Next, there is a “backward” pass, which operates on the hidden states in a reverse order to propagate an error signal $\delta ^ { l }$ back down the network. In this process, a hidden state $h ^ { l }$ is created for each layer. These h are tensors with a batch, neuron and feature index: $h ^ { l } \in \mathbb { R } ^ { B , N ^ { l } , \lambda _ { h d i m s } }$ where $\lambda _ { h d i m s } = 6 4$ . Weight updates to $W ^ { l }$ and $b ^ { l }$ are then readout from these $h ^ { l }$ and other signals found both locally, and in aggregate along both batch and neuron.
+
+# G.4.1 BACKWARD ERROR PROPAGATION
+
+In backprop, there exists a single scalar error signal that gets backpropagated back down the network. In our work, this error signal does not exist as there is no loss being optimized. Instead we have a learned top-down signal, $\dot { d } ^ { L }$ , at the top of the network. Because we are no longer restricted to the form of backprop, we make this quantity a vector for each unit in the network, rather than a scalar,
+
+$$
+\begin{array} { c } { x ^ { 0 } \sim \mathcal { D } , x ^ { 0 } \in \mathbb { R } ^ { B , N _ { x } } } \\ { \{ z ^ { 1 } . . . z ^ { L } , x ^ { 0 } . . . x ^ { L } , \phi \} = f ( x ; \phi ) } \\ { d ^ { L } = \mathrm { T o p D } ( x ^ { L } ; \theta _ { t o p D } ) } \end{array}
+$$
+
+where $d ^ { l } \in \mathbb { R } ^ { B , N ^ { l } , \lambda _ { d e l t a d i m s } }$ . In this work we set $\lambda _ { d e l t a d i m s } = 3 2 $ . The architecture of TopD is a neural network that operates along every dimension of $x ^ { L }$ . The specification can be found in G.7.
+
+We structure our error propagation similarly to the structure of the backpropagated error signal in a standard MLP with contributions to the error at every layer in the network,
+
+$$
+\delta _ { i j d } ^ { l } = d _ { i j d } ^ { l } \odot \sigma \big ( z _ { i j d } ^ { l } \big ) + \sum _ { k } ^ { \lambda _ { h d i m s } } \big ( \theta _ { e r r o r P r o p W } \big ) _ { k d } h _ { i j k } ^ { l } + \big ( \theta _ { e r r o r P r o p B } \big ) _ { d }
+$$
+
+where $\delta ^ { l }$ has the same shape as $d ^ { l }$ , and $\theta _ { e r r o r P r o p W } \ \in \ \mathbb { R } ^ { \lambda _ { h d i m s } , \lambda _ { d e l t a d i m s } }$ and $\theta _ { e r r o r P r o p B } \ \in$ $\mathbb { R } ^ { \lambda _ { d e l t a d i m s } }$ . Note both $\theta _ { e r r o r P r o p W }$ and $\theta _ { e r r o r P r o p B }$ are shared for all layers $l$ .
+
+In a similar way to backprop, we move this signal down the network via multiplying by a backward weight matrix $( \dot { V } ^ { l } )$ . We do not use the previous weight matrix transpose as done in backprop, instead we learn a separate set of weights that are not tied to the forward weights and updated along with the forward weights as described in G.5. Additionally, we normalize the signal to have fixed second moment,
+
+$$
+\begin{array} { l } { { \displaystyle { \tilde { d } } _ { i m d } ^ { l } = \sum _ { j } ^ { N ^ { l + 1 } } \delta _ { i j d } ^ { l + 1 } ( V ^ { l + 1 } ) _ { m j } } } \\ { { \displaystyle { \tilde { d } } _ { i m d } ^ { l } = \hat { d } _ { i m d } ^ { l } \left( \frac { 1 } { \lambda _ { d e l t a d i m s } } \sum _ { a } ^ { \lambda _ { d e l t a d i m s } } \tilde { d } _ { i m a } ^ { l } \right) ^ { - \frac { 1 } { 2 } } } } \end{array}
+$$
+
+The internal $h ^ { l } \in \mathbb { R } ^ { B , N ^ { l } , \lambda _ { h d i m s } }$ vectors are computed via:
+
+$$
+h ^ { l } = \mathrm { C o m p u t e H } \left( d ^ { l } , x ^ { l } , z ^ { l } ; \theta _ { c o m p u t e H } \right)
+$$
+
+The architecture of ComputeH is a neural network that operates on every dimension of all the inputs. It can be found in G.8. These definitions are recursive, and are computed in order: $h ^ { L } , h ^ { L - 1 } \cdot \cdot \cdot h ^ { 1 ^ { \prime } } , h ^ { 0 }$ . With these computed, weight updates can be read out (Section G.5). When the corresponding symbols are not defined (e.g. $z ^ { 0 }$ ) a zeros tensor with the correct shape is used instead.
+
+# G.5 WEIGHT UPDATES
+
+The following is the implementation of ComputeDeltaWeight $( x ^ { 0 } \cdot \cdot \cdot x ^ { L } , z ^ { 1 } \cdot \cdot \cdot z ^ { L } , \phi ; \theta )$
+
+For a given layer, $l$ , our weight updates are a mixture of multiple low rank readouts from $h ^ { l }$ and $h ^ { l - 1 }$ . These terms are then added together with a learnable weight, in $\theta$ to form a final update. The final update is then normalized mixed with the previous weights. We update both the forward, $W ^ { l }$ , and the backward, $V ^ { l }$ , using the same update rule parameters $\theta$ . We show the forward weight update rule here, and drop the backward for brevity.
+
+For convenience, we define a low rank readout function LowRR that takes $h ^ { l }$ like tensors, and outputs a single lower rank tensor.
+
+$$
+\begin{array} { r l } & { \mathrm { L o w R R } ( h ^ { a } , h ^ { b } ; \Theta ) : : } \\ & { \quad \quad \quad ( \mathbb { R } ^ { B , N ^ { a } , \lambda _ { h d i m s } } , \mathbb { R } ^ { B , N ^ { b } , \lambda _ { h d i m s } } )  \mathbb { R } ^ { N ^ { \prime \prime } , N ^ { b } } } \end{array}
+$$
+
+Here, $\Theta$ , is a placehoder for the parameters of the given readout. LowRR is defined as:
+
+$$
+\begin{array} { l } { { \displaystyle \Theta = \{ P ^ { a } , P ^ { b } \} ~ \mathrm { w h e r e } ~ P ^ { a } \in \mathbb { R } ^ { \lambda _ { h d m s } , \lambda _ { g r a d c } } } } \\ { { \displaystyle r _ { i j p } ^ { a } = \sum _ { k } h _ { i j k } ^ { a } P _ { k p } ^ { a } } } \\ { { \displaystyle r _ { i j p } ^ { b } = \sum _ { k } h _ { i j k } ^ { b } P _ { k p } ^ { b } } } \\ { { \displaystyle \mathrm { L o w R R } ( \cdot ) _ { j p } = \sum _ { i } ^ { B } \sum _ { k } r _ { i j k } ^ { a d c } r _ { i j k } ^ { b } r _ { i j k } ^ { a } \frac { 1 } { B \lambda _ { h d i m s } } } } \end{array}
+$$
+
+where $\lambda _ { g r a d c } = 4$ and is the rank of the readout matrix (per batch element).
+
+# G.5.1 LOCAL TERMS
+
+This sequence of terms allow the weight to be adjusted as a function of state in the pre- and postsynaptic neurons. They should be viewed as a basis function representation of the way in which the weight changes as a function of pre- and post-synaptic neurons, and the current weight value. We express each of these contributions to the weight update as a sequence of weight update planes, with the ith plane written $\Delta W _ { i } ^ { l } \in \mathbb { R } ^ { N ^ { l - 1 } \times N ^ { l } }$ . Each of these planes will be linearly summed, with coefficients generated as described in Equation App.57, in order to generate the eventual weight update.
+
+$$
+\begin{array} { l }  { \displaystyle { \hat { W } ^ { l } = \frac { W ^ { l } } { \sqrt { \frac { 1 } { N ^ { 1 - 1 } } \sum _ { i } ^ { N ^ { l - 1 } } \left( W ^ { l } \right) _ { i } ^ { 2 } } } } } \\ { { \displaystyle \Delta W _ { 1 } ^ { 1 } = \bar { W } ^ { l } } } \\ { { \displaystyle \Delta W _ { 2 } ^ { l } = \langle \bar { W } ^ { l } \rangle ^ { 2 } s i g n ( \hat { W } ^ { l } ) } } \\ { { \displaystyle \Delta W _ { 3 } ^ { 1 } = \mathrm { l o w } [ \mathrm { R } ( h ^ { l - 1 } , h ^ { l } ; g _ { z e e e } ) ] } } \\ { { \displaystyle \Delta W _ { 4 } ^ { 1 } = \mathrm { e x p } ( - \langle \bar { W } _ { b } ^ { l } \rangle ^ { 2 } ) \odot \mathrm { L o w R R } ( h ^ { l - 1 } , h ^ { l } ; \theta _ { b f r b f } ) } } \\ { { \displaystyle \Delta W _ { 5 } ^ { 1 } = W _ { b } ^ { 1 } \odot \mathrm { L o w R R } ( h ^ { l - 1 } , h ^ { l } ; \theta _ { l i r s t } ) } } \\ { { \displaystyle \Delta W _ { 6 } ^ { 1 } = \frac { 1 } { B } \frac { B } { b } \left( x _ { b } ^ { l - 1 } - \frac { 1 } { B } \frac { B } { b ^ { 1 } } x _ { b } ^ { l - 1 } \right) ^ { T } \left( x _ { b } ^ { l } - \frac { 1 } { B } \frac { B } { b ^ { 1 } } x _ { b } ^ { l } \right) ^ { T } } } \end{array}
+$$
+
+# G.5.2 DECORRELATION TERMS
+
+Additional weight update planes are designed to aid units in remaining decorrelated from each other’s activity, and in decorrelating their receptive fields. Without terms like this, a common failure mode
+
+is for many units in a layer to develop near-identical representations. Here, $S _ { i } ^ { l }$ indicates a scratch matrix associated with weight update plane $i$ and layer $l$ .
+
+$$
+\begin{array} { r l } & { \quad S _ { T } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } \operatorname { L o n e r B E } ( h , \hat { u } ^ { - 1 } , h ^ { - 1 } , \theta _ { 0 \le t \le m \le N \le n } ) } \\ & { \quad \Delta N _ { T } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } [ ( S _ { T } ^ { \prime } + ( S _ { T } ^ { \prime } ) ^ { T } ) \Phi ( 1 - T ) ] W ^ { T } } \\ & { \quad S _ { T } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } \operatorname { L o n e r B E } ( h ^ { - 1 } , h ^ { - 1 } , \theta _ { 0 \le t \le m \le N \le n } ) } \\ & { \quad \Delta N _ { t } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } [ ( S _ { T } ^ { \prime } + ( S _ { T } ^ { \prime } ) ^ { T } ) \Phi ( 1 - T ) ] ( \sqrt { N ^ { 3 } + ( \theta _ { T } ^ { \prime } ) ^ { T } } - 1 ) } \\ & { \quad \quad S _ { T } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } \operatorname { L o n e r B R } ( h , \hat { u } ^ { \prime } , h _ { 0 \le t \le T \le s } ) \operatorname { a n d } } \\ & { \quad \Delta N _ { t } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } \operatorname { L o n e r B e r } ( h , \hat { u } ^ { \prime } , h _ { 0 \le t \le T \le s } ) \operatorname { a n d } } \\ & { \quad \Delta N _ { t } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } \operatorname { L o n e r B } ( h ^ { - 1 } , \theta _ { 0 \le t \le s } ) \operatorname { a n d } } \\ & { \quad \quad S _ { T } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } \operatorname { L o n e r B } ( h ^ { - 1 } , h ^ { - 1 } , \theta _ { 0 \le t \le s } ) \operatorname { a n d } } \\ &  \quad \quad \Delta N _ { t } ^ { \prime } = \frac { 1 } { \sqrt { N ^ { 3 } - 1 } } ( \int _ { 0 } ^ { 1 } ( S _ { T } ^ { \prime } + ( S _ { T } ^ { \prime } ) ^ { T } ) \Phi ( 1 - ( S _ { T } ^  \end{array}
+$$
+
+# G.6 APPLICATION OF THE WEIGHT TERMS IN THE OPTIMIZER
+
+We then normalize, re-weight, and merge each of these weight update planes into a single term, which will be used in the weight update step,
+
+$$
+\begin{array} { c } { \displaystyle \Delta \tilde { W } _ { i } ^ { l } = \frac { \Delta W _ { i } ^ { l } } { \sqrt { 1 + \frac { 1 } { N ^ { l - 1 } N ^ { l } } \sum _ { m } ^ { N ^ { l - 1 } } \sum _ { n } ^ { N ^ { l } } \left( \Delta W _ { i m n } ^ { l } \right) ^ { 2 } } } } \\ { \displaystyle ( \Delta W _ { m e r g e } ^ { l } ) _ { j k } = \frac { 1 } { B } \sum _ { i } ^ { B } ( \theta _ { m e r g e W } ) _ { i } \Delta \tilde { W } _ { i j k } ^ { l } , } \end{array}
+$$
+
+where $\theta _ { m e r g e W } \in \mathbb { R } ^ { 1 0 }$ (as we have 10 input planes).
+
+To prevent pathologies during training, we perform two post processing steps to prevent the learned optimizer from cheating, and increasing its effective learning rate, leading to instability. We only allow updates which do not decrease the weight matrix magnitude,
+
+$$
+\Delta W _ { o r t h } ^ { l } = \Delta W _ { m e r g e } ^ { l } - \hat { W } ^ { l } \mathrm { R e L U } ( \Delta W _ { m e r g e } \cdot \hat { W } ^ { l } ) ,
+$$
+
+where $\hat { W } ^ { l }$ is $W ^ { l }$ scaled to have unit norm, and we normalize the length of the update,
+
+$$
+\Delta W _ { f i n a l } ^ { l } = \frac { \Delta W _ { o r t h } ^ { l } } { \sqrt { 1 + \frac { 1 } { N ^ { l - 1 } N ^ { l } } \sum _ { m } ^ { N ^ { l - 1 } } \sum _ { n } ^ { N ^ { l } } \left( \Delta W _ { o r t h } ^ { l } \right) _ { m n } ^ { 2 } } }
+$$
+
+To compute changes in the biases, we do a readout from $h ^ { l }$ . We put some constraints on this update to prevent the biases from pushing all units into the linear regime, and minimizing learning. We found this to be a possible pathology.
+
+$$
+\begin{array} { r } { \displaystyle \Delta b _ { b a s e } ^ { l } = \frac { 1 } { B } \sum _ { i } ^ { B } { \displaystyle \sum _ { k } ^ { \lambda _ { h d i m s } } { ( \theta _ { B r e a d o u t } ) _ { k } h _ { i j k } ^ { l } } } } \\ { \displaystyle \Delta b _ { c o n s t r a i n e d } ^ { l } = \Delta b _ { b a s e } ^ { l } - \mathrm { R e L U } \left( - \frac { 1 } { N ^ { l } } \sum _ { i } ^ { N ^ { l } } { \left( \Delta b _ { b a s e } ^ { l } \right) _ { i } } \right) , } \end{array}
+$$
+
+where $\theta _ { B r e a d o u t } \in \mathbb { R } ^ { \lambda _ { h d i m s } }$ .
+
+We then normalize the update via the second moment:
+
+$$
+\Delta b _ { f i n a l } ^ { l } = \frac { \Delta b _ { c o n s t r a i n e d } ^ { l } } { \frac { 1 } { N ^ { l } } \sum _ { i } ^ { N ^ { l } } ( \Delta b _ { c o n s t r a i n e d } ^ { l } ) _ { i } ^ { 2 } }
+$$
+
+Finally, we define ComputeDeltaWeight as all layer’s forward weight updates, and backward weight updates, and bias updates.
+
+$$
+\mathrm { C o m p u t e D e l t a W e i g h t } ( x ^ { 0 } \cdot \cdot \cdot x ^ { L } , z ^ { 1 } \cdot \cdot \cdot z ^ { L } , \phi _ { t } ; \theta ) = ( \Delta W _ { f i n a l } ^ { 1 \cdot \perp L } , \Delta b _ { f i n a l } ^ { 1 \cdot \perp L } , \Delta V _ { f i n a l } ^ { 1 \cdot \perp L } )
+$$
+
+# G.7 TopD
+
+This function performs various convolutions over the batch dimension and data dimension. For ease of notation, we use $m$ as an intermediate variable. Additionally, we drop all convolution and batch norm parameterizations. They are all separate elements of $\theta _ { t o p D }$ . We define two 1D convolution operators that act on rank 3 tensors: ConvBatch which performs convolutions over the zeroth index, and ConvUnit which performs convolutions along the firs index. We define the $S$ argument to be size of hidden units, and the $K$ argument to be the kernel size of the 1D convolutions. Additionally, we set the second argument of BatchNorm to be the axis normalized over.
+
+$$
+\mathrm { T o p D } ( x ^ { L } ; \theta _ { t o p D } ) : : \mathbb { R } ^ { B , N ^ { L } }  \mathbb { R } ^ { B , N ^ { L } , \lambda _ { d e l t a d i m s } }
+$$
+
+First, we reshape to add another dimension to the end of $x ^ { L }$ , in pseudocode:
+
+$$
+m _ { 0 } = [ x ^ { L } ]
+$$
+
+Next, a convolution is performed on the batch dimension with a batch norm and a ReLU non linearity.   
+This starts to pull information from around the batch into these channels.
+
+$$
+\begin{array} { r l } & { m _ { 1 } = \mathrm { { C o n v B a t c h } } \left( { m _ { 0 } , S = \lambda _ { t o p d e l t a s i z e } , K = 5 } \right) } \\ & { m _ { 2 } = \mathrm { { R e L U } } \left( { \mathrm { B a t c h N o r m } \left( { m _ { 1 } , \mathord { \left[ 0 , 1 \right] }  } } \righ\right)t) } \end{array}
+$$
+
+We set $\lambda _ { t o p d e l t a s i z e } = 6 4$ . Next, a series of unit convolutions (convolutions over the last dimension) are performed. These act as compute over information composed from the nearby elements of the batch. These unit dimensions effectively rewrite the batch dimension. This restricts the model to operate on a fixed size batch.
+
+$$
+\begin{array} { r l } & { m _ { 3 } = \mathrm { C o n v U n i t } \left( m _ { 2 } , S = B , K = 3 \right) } \\ & { m _ { 4 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 3 } , [ 0 , 1 ] \right) \right) } \\ & { m _ { 5 } = \mathrm { C o n v U n i t } \left( m _ { 4 } , S = B , K = 3 \right) } \\ & { m _ { 6 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 5 } , [ 0 , 1 ] \right) \right) } \end{array}
+$$
+
+Next a series of 1D convolutions are performed over the batch dimension for more compute capacity.
+
+$$
+\begin{array} { r l } & { m _ { 7 } = \mathrm { C o n v B a t c h } \left( m _ { 6 } , S = \lambda _ { t o p d e l t a s i z e } , K = 3 \right) } \\ & { m _ { 8 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 7 } , \left[ 0 , 1 \right] \right) \right) } \\ & { m _ { 9 } = \mathrm { C o n v B a t c h } \left( m _ { 8 } , S = \lambda _ { t o p d e l t a s i z e } , K = 3 \right) } \\ & { m _ { 1 0 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 9 } , \left[ 0 , 1 \right] \right) \right) } \end{array}
+$$
+
+Finally, we convert the representations to the desired dimensions and output.
+
+$$
+\begin{array} { c } { { m _ { 1 1 } = \mathrm { C o n v B a t c h } \left( m _ { 1 0 } , S = \lambda _ { d e l t a d i m s } , K = 3 \right) } } \\ { { { \mathrm { T o p D } \left( x ^ { L } ; \theta _ { t o p D } \right) = m _ { 1 1 } } } } \end{array}
+$$
+
+# G.8 ComputeH
+
+This is the main computation performed while transfering signals down the network and the output is directly used for weight updates. It is defined as:
+
+$$
+\begin{array} { r l } & { \mathrm { C o m p u t e H } \left( d ^ { l } , x ^ { l } , z ^ { l } , W ^ { l } , W ^ { l + 1 } , b ^ { l } ; \theta _ { c o m p u t e H } \right) : : } \\ & { \left( \mathbb { R } ^ { B , N ^ { l } , \lambda _ { d e l t a d i m s } } , \mathbb { R } ^ { B , N ^ { l } } , \mathbb { R } ^ { B , N ^ { l } } , \mathbb { R } ^ { N ^ { l - 1 } , N ^ { l } } , \mathbb { R } ^ { N ^ { 1 } , N ^ { l + 1 } } , \mathbb { R } ^ { N ^ { l } } \right) \to \left( \mathbb { R } ^ { B , N ^ { l } , \lambda _ { h d i m s } } \right) } \end{array}
+$$
+
+The outputs of the base model, $( x ^ { l } , z ^ { l } )$ , plus an additional positional embeddings are stacked then concatenated with $d$ , to form a tensor in $\mathbb { R } ^ { B , N ^ { l } , ( 4 + \lambda _ { d e l t a d i m s } ) }$ :
+
+$$
+\begin{array} { r l } & { \displaystyle ( { p ^ { 0 } } ) _ { i j } = \sin ( \frac { 2 j \pi } { N ^ { l } } ) } \\ & { \displaystyle ( { p ^ { 1 } } ) _ { i j } = \cos ( \frac { 2 j \pi } { N ^ { l } } ) } \\ & { \quad \quad m _ { 0 } = [ x ^ { l } , z ^ { l } , p ^ { 0 } , p ^ { 1 } ] \mathrm { w h e r e } m _ { 0 } \in \mathbb R ^ { B , N ^ { l } , 4 } } \\ & { \quad m _ { 1 } = [ m _ { 0 } ; d ^ { l } ] } \end{array}
+$$
+
+Statistics across the batch and unit dimensions, 0 and 1, are computed. We define a Statsi function bellow. We have 2 instances for both the zeroth and the first index, shown bellow is the zeroth index and the first is omitted.
+
+$$
+\begin{array} { c } { { \mathrm { \normalfont ~ \hat { s t a n s } _ \bot ( ~ } w ) : \displaystyle \mathbb { R } ^ { R ^ { 0 } } \cdot \mathbb { R } ^ { t } \to \mathbb { R } ^ { R ^ { 1 } } \to \mathbb { R } ^ { R ^ { 1 } } \times } } \\ { { \mathrm { \normalfont ~ \hat { \rho } ( s _ { 1 } ) } _ { \lambda } = \displaystyle \frac { 1 } { K ^ { 0 } } \sum _ { i = 1 } ^ { K ^ { 0 } } \mathrm { a l s } ( w _ { i i } ) } } \\ { { \mathrm { \normalfont ~ \hat { \rho } ( s _ { 2 } ) } _ { j } = \displaystyle \sqrt { \frac { 1 } { K ^ { 0 } } \sum _ { j ^ { \prime } } ^ { R ^ { 0 } } ( w _ { j i } ) ^ { 2 } } } } \\ { { \mathrm { \normalfont ~ \hat { \rho } ( s _ { j } ) } _ { j } = \displaystyle \frac { 1 } { K ^ { 0 } } \sum _ { j ^ { \prime } } ^ { R ^ { 0 } } w _ { i j } } } \\ { { \mathrm { \normalfont ~ \hat { \rho } ( s _ { j } ) } _ { j ^ { \prime } } = \displaystyle \frac { 1 } { K ^ { 0 } } \sum _ { i = 1 } ^ { K ^ { 0 } } ( s _ { j i } ) _ { i ^ { \prime } } } } \\ { { \mathrm { \normalfont ~ \hat { \rho } ( s _ { j } ) } _ { j ^ { \prime } } = \displaystyle \sqrt { \frac { 1 } { K ^ { 0 } } \sum _ { j ^ { \prime } } ^ { R ^ { 0 } } ( s _ { j i } ) _ { i ^ { \prime } } - w _ { i j } ) ^ { 2 } } } } \\ { { \mathrm { \normalfont ~ \hat { \rho } ( a t  { s } _ { 1 } ) } _ { i ^ { \prime } } , } } \end{array}
+$$
+
+We the compute statistics of the weight matrix below, and above. We tile the statistics to the appropriate dimensions and concatenate with normalized inputs as well as with the bias (also tiled appropriately).
+
+$$
+\begin{array} { r l r } {  { ( s _ { 0 } ) _ { i j k } = ( \mathrm { S t a t s } _ { 0 } ( W ^ { l } , 0 ) ) _ { j } } } \\ & { ( s _ { 1 } ) _ { i j k } = ( \mathrm { S t a t s } _ { 1 } ( W ^ { l + 1 } , 1 ) ) _ { i } } \\ & { } & { m _ { 2 } = \mathrm { B a t c h N o r m } ( m _ { 1 } , [ 0 , 1 ] ) } \\ & { } & { \hat { b } _ { i j k } = b _ { j } ^ { l } \mathrm { ~ w h e r e ~ } \hat { b } \in \mathbb { R } ^ { B , N ^ { l } , 1 } } \\ & { } & { m _ { 3 } = [ s _ { 0 } ; s _ { 1 } ; m _ { 2 } ; \hat { b } ] \mathrm { ~ w h e r e ~ } m _ { 3 } \in \mathbb { R } ^ { B , N ^ { l } , 4 + 4 + ( 4 + \lambda _ { d e l t a d i m s } ) + 1 } } \end{array}
+$$
+
+With the inputs prepared, we next perform a series of convolutions on batch and unit dimensions, (0, 1).
+
+$$
+\begin{array} { r l } & { m _ { 4 } = \mathrm { C o n v B a t c h } \left( m _ { 3 } , S = \lambda _ { c o m p u t e h s i z e } , K = 3 \right) } \\ & { m _ { 5 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 4 } , \left[ 0 , 1 \right] \right) \right) } \\ & { m _ { 6 } = \mathrm { C o n v U n i t } \left( m _ { 5 } , S = \lambda _ { c o m p u t e h s i z e } , K = 3 \right) } \\ & { m _ { 7 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 6 } , \left[ 0 , 1 \right] \right) \right) } \\ & { m _ { 8 } = \mathrm { C o n v B a t c h } \left( m _ { 7 } , S = \lambda _ { c o m p u t e h s i z e } , K = 3 \right) } \\ & { m _ { 9 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 8 } , \left[ 0 , 1 \right] \right) \right) } \\ & { m _ { 1 0 } = \mathrm { C o n v U n i t } \left( m _ { 9 } , S = \lambda _ { c o m p u t e h s i z e } , K = 3 \right) } \\ & { m _ { 1 1 } = \mathrm { R e L U } \left( \mathrm { B a t c h N o r m } \left( m _ { 1 0 } , \left[ 0 , 1 \right] \right) \right) } \end{array}
+$$
+
+The result is then output.
+
+$$
+\mathrm { C o m p u t e H } \left( \cdot ; \theta _ { c o m p u t e H } \right) = m _ { 1 1 }
+$$
+
+We set $\lambda _ { c o m p u t e h s i z e } = 6 4$ which is the inner computation size.
+
+# H EXPERIMENTAL DETAILS
+
+# H.1 META TRAINING
+
+# H.1.1 TRAINING DATA DISTRIBUTION
+
+We trained on a data distribution consisting of tasks sampled uniformly over the following datasets. Half of our training tasks where constructed off of a dataset consisting of 1000 font rendered characters. We resized these to 14x14 black and white images. We call this the glyph dataset. "Alphabet" is an example of such a dataset consisting of alphabet characters. We used a mixture 10, 13, 14, 17, 20, and 30 way classification problems randomly sampled, as well as sampling from three 10-way classification problems sampled from specific types of images: letters of the alphabet, math symbols, and currency symbols. For half of the random sampling and all of the specialized selection we apply additional augmentation. This augmentation consists of random rotations (up to 360 degrees) and shifts up to $+ { - } 5$ pixels in the x and y directions. The parameters of the augmentation were inserted into the regression target of the MetaObjective as a curriculum of sorts and to provide diverse training signal.
+
+In addition to the the glyph set, we additionally used Cifar10, resized to 16x16, as well as 10, 15, 20, and 25 way classification problems from imagenet. Once again we resized to 16x16 for compute reasons.
+
+With a dataset selected, we apply additional augmentation with some probability consisting of the following augmentations. A per task dropout mask (fixed mask across all images in that task). A per example dropout mask (a random mask per image). A permutation sampled from a fixed number of pre created permutations per class. A per image random shift in the x direction each of image. All of these additional augmentations help with larger domain transfer.
+
+# H.2 META-OPTIMIZATION
+
+We employ Adam (Kingma and Ba, 2014) as our meta-optimizer. We use a learning rate schedule of 3e-4 for the first $1 0 0 \mathrm { k }$ steps, then 1e-4 for next 50k steps, then 2e-5 for remainder of meta-training. We use gradient clipping of norm 5 on minibatchs of size 256.
+
+We compute our meta-objective by averaging 5 evaluation of the linear regression. We use a ridge penalty of 0.1 for all this work.
+
+When computing truncated gradients, we initially sample the number of unrolled applications of the UnsupervisedUpdate in a uniform distribution of [2,4]. This is the number of steps gradients are backpropogated through. Over the course of 50k meta-training steps we uniformly increase this to [8,15]. This increases meta-training speed and stability as large unrolls early in training can be unstable and don’t seem to provide any value.
+
+For sampling the number of truncated steps (number of times the above unrolls are performed), we use a shifted normal distribution – a normal distribution with the same mean and standard deviation. We chose this based on the expected distribution of the training step, $\phi$ iteration number, across the cluster of workers. We initially set the standard deviation low, 20, but slowly increased it over the course of 5000 steps to $2 0 \mathrm { k }$ steps. This slow increase also improved stability and training speed.
+
+# H.3 EXPERIMENTAL SETUP
+
+For each experimental figure, we document the details.
+
+# H.3.1 OBJECTIVE FUNCTION MISMATCH
+
+The VAE we used consists of 3 layers, size 128, with ReLU activations and batch norm between each layer. We then learn a projection to mean and log std of size 32. We sample, and use the inverse architecture to decode back to images. We use a quantized normal distribution (once again parameterized as mean and log std) as a posterior. We train with Adam with a learning rate of 1e-4. To isolate the effects of objective function mismatch and overfitting, we both train on the unlabeled training set and evaluate on the labeled training set instead of a validation set.
+
+# H.3.2 GENERALIZATION: DATASET AND DOMAIN
+
+We use a 4 layer, size 128 unit architecture with a 32 layer embedding for all models. We select performance at $1 0 0 \mathrm { k }$ training steps for the VAE, and 3k for our learned optimizer.
+
+Our supervised learning baseline consists of the same architecture for the base model but with an additional layer that outputs log probabilities. We train with cross entropy loss on a dataset consisting of only 10 examples per class (to match the other numbers). Surprisingly, the noise from batch norm acts as a regularizer, and allowing us to avoid needing a complex early stopping scheme as test set performance simply plateaus over the course of 10k steps. We train with Adam with a learning rate of 3e-3, selected via a grid over learning rate on test set performance. In this setting, having a true validation set would dramatically lower the amount of labeled data available (only 100 labeled examples) and using the test set only aids in the this baseline’s performance.
+
+For the IMDB experiments, we tokenized and selected the top 1K words with an additional set of tokens for unknown, sentence start, and sentence end. Our encoding consisted of a 1 if the word is present, otherwise 0. We used the same 4 layer, 128 hidden unit MLP with an addition layer outputting a 32 dimensional embedding.
+
+# H.3.3 GENERALIZATION: NETWORK ARCHITECTURE
+
+We used ReLU activations and 4 layers of size 128 with an additional layer to 32 units unless otherwise specified by the specific experiment.
+
+# H.3.4 EXISTING META LEARNING MODELS
+
+We trained prototypical networks (Snell et al., 2017) on either intact or shuffled mini-Imagenet images. For shuffled images, we generated a fixed random permutation for the inputs independently for every instantiation of the base network (or ’episode’ in the meta-learning literature (Vinyals et al., 2016; Ravi and Larochelle, 2016)). The purpose of shuffling was to demonstrate the inductive bias of this type of meta-learning, namely that they do not generalize across data domain. Note that the base network trained was the same fully connected architecture like that used in this paper (3 layers, size 128, with ReLU activations and batch normalization between layers). Though the original paper used a convolutional architecture, here we swapped it with the fully connected architecture because the tied weights in a convolutional model do not make sense with shuffled pixels.

parse/train/_b8l7rVPe8z/_b8l7rVPe8z_content_list.json

@@ -0,0 +1,2035 @@
+[
+    {
+        "type": "text",
+        "text": "RELEVANCE ATTACK ON DETECTORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            99,
+            622,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            400,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper focuses on high-transferable adversarial attacks on detectors, which are hard to attack in a black-box manner, because of their multiple-output characteristics and the diversity across architectures. To pursue a high attack transferability, one plausible way is to find a common property across detectors, which facilitates the discovery of common weaknesses. We are the first to suggest that the relevance map for detectors is such a property. Based on it, we design a Relevance Attack on Detectors (RAD), which achieves a state-of-the-art transferability, exceeding existing results by above $20 \\%$ . On MS COCO, the detection mAPs for all 8 black-box architectures are more than halved and the segmentation mAPs are also significantly influenced. Given the great transferability of RAD, we generate the first adversarial dataset for object detection, i.e., Adversarial Objects in COntext (AOCO), which helps to quickly evaluate and improve the robustness of detectors. ",
+        "bbox": [
+            233,
+            238,
+            766,
+            405
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            428,
+            336,
+            443
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial attacks (Szegedy et al. (2014); Goodfellow et al. (2015); Carlini & Wagner (2017); M ˛adry et al. (2017); Baluja & Fischer (2017); Su et al. (2019)) have revealed the fragility of Deep Neural Networks (DNNs) by fooling them with elaborately-crafted imperceptible perturbations. Among them, the black-box attack, i.e., attacking without knowledge of their inner structure and weights, is much harder, more aggressive and closer to real-world scenarios. For classifiers, there exist some promising black-box attacks (Papernot et al. (2016); Brendel et al. (2018); Dong et al. (2018); Xie et al. (2019); Lin et al. (2020); Chen et al. (2020)). It is also severe to attack object detection (Zhang & Wang (2019)) in a black-box manner, e.g., hiding certain objects from unknown detectors (Thys et al. (2019)). By that, life-concerning systems based on detection such as autonomous driving and security surveillance would be greatly influence. ",
+        "bbox": [
+            174,
+            457,
+            825,
+            597
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, no existing attack is specifically designed for black-box transferability in detectors, because they have multiple-outputs and a high diversity across architectures. In such situations, adversarial samples do not transfer well (Su et al. (2018)), and most attacks only decrease mAP of black-box detectors by 5 to $10 \\%$ (Xie et al. (2017); Li et al. (2018c;b)). To overcome this, we propose one plausible way to find common properties across detectors, which facilitates the discovery of common weaknesses. Based on them, the designed attack can threaten variable victims. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we adopt the relevance map as a common property, on which different detectors have similar interpretable results, as shown in Fig. 1. Based on relevance maps, we design a Relevance Attack on Detectors (RAD). RAD focuses on suppressing the relevance map rather than directly attacking the prediction as in existing works (Xie et al. (2017); Li et al. (2018c;a)). Because the relevance maps are quite similar across models, those of black-box models are influenced and misled as well in attack, leading to the great transferability. Although some works have adopted the relevance map as an indicator or reference of success attacks (Dong et al. (2019); Zhang & Zhu (2019); Chen et al. (2020); Wu et al. (2020a)), there is no work to directly attack the relevance maps of detectors to the best of our knowledge. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In our comprehensive evaluation, RAD achieves the state-of-the-art transferability on 8 black-box models for COCO) dataset (Lin et al. (2014)), nearly halving the detection mAP. Interestingly, the adversarial samples of RAD also greatly influence the performance of instance segmentation, even only detectors are attacked. Given the high transferability of RAD, we create Adversarial Objects in COntext (AOCO), the first adversarial dataset for object detection. AOCO contains 10K samples that significantly decrease the performance of black-box models for detection and segmentation. AOCO may serve as a benchmark to test the robustness of a DNN or improve it by adversarial training. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/532cf52146221673a00f7d8064e690df7110aa3752fa5b8559f71cea00249ecd.jpg",
+        "image_caption": [
+            "Figure 1: Relevance maps for models with different architectures. Three models not only predict the “stop sign” right, but also share similar relevance maps. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            102,
+            790,
+            220
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "CONTRIBUTIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            291,
+            292,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose a novel attack framework on relevance maps for detectors. We extend network visualization methods to detectors, find out the most suitable nodes to attack by relevance maps, and explore on the best update techniques to increase the transferability. • We evaluate RAD comprehensively and find its state-of-the-art transferability, which exceeds existing results by above $20 \\%$ . Detection mAPs are more than halved, invalidating the stateof-the-art detectors to a large extent. By RAD, we create the first adversarial dataset for object detection, i.e., AOCO. As a potential benchmark, AOCO is generated from COCO and contains 10K high-transferable samples. AOCO helps to quickly evaluate and improve the robustness of detectors. ",
+        "bbox": [
+            214,
+            313,
+            825,
+            448
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            344,
+            483
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Since (Szegedy et al. (2014)), there have been lots of promising adversarial attacks (Goodfellow et al. (2015); Carlini & Wagner (2017); M ˛adry et al. (2017)). Generally, they fix the network weights and change the input slightly to optimize the attack loss. The network then predicts incorrectly on adversarial samples with a high confidence. (Papernot et al. (2016; 2017)) find that adversarial samples crafted by attacking a white-box surrogate model may transfer to other black-box models as well. Input modification (Xie et al. (2019); Dong et al. (2019); Lin et al. (2020)) or other optimization ways (Dong et al. (2018); Lin et al. (2020)) are validated to be effective in enhancing the transferability. ",
+        "bbox": [
+            174,
+            498,
+            825,
+            597
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(Xie et al. (2017)) extends adversarial attacks to detectors. It proposes to attack on densely generated bounding boxes. After that, losses about localization and classification are designed (Li et al. (2018c)) for attacking detectors. (Lu et al. (2017)) and (Li et al. (2018a)) propose to attack detectors in a restricted area. Existing works achieve good results in white-box scenarios, but are not specifically designed for transferability. The adversarial impact on black-box models is quite limited, i.e., a 5 to $10 \\%$ decrease from the original mAP, even when two models only differ in backbone (Xie et al. (2017); Li et al. (2018c;b)). (Wang et al. (2020)) discusses black-box attacks towards detectors based on queries rather than the transferability as we do. The performance is satisfactory, but it requires over 30K queries, which is easy to be discovered by the model owner. Besides, physical attacks on white-box detectors are also feasible (Huang et al. (2020); Wu et al. (2020b); Xu et al. (2020)). ",
+        "bbox": [
+            174,
+            603,
+            825,
+            742
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For the great transferability, we propose to attack on relevance maps, which are calculated by network visualization methods (Zeiler & Fergus (2014); Selvaraju et al. (2017); Shrikumar et al. (2017)). They are originally developed to interpret how DNNs predict and help users gain trust on them. Specifically, they display how the input contributes to a certain node output in a pixel-wise manner. Typical works include Layer-wise Relevance Propagation (LRP) (Bach et al. (2015)), Contrastive LRP (Gu et al. (2018)) and Softmax Gradient LRP (SGLRP) (Iwana et al. (2019)). These methods encourage the reference of relevance maps in attack (Dong et al. (2019); Zhang & Zhu (2019); Chen et al. (2020); Wu et al. (2020a)), and also inspire us. However, none of them attack on relevance maps for detectors. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "RAD differs from (Ghorbani et al. (2019); Zhang et al. (2020)) in the goal. RAD misleads detectors by suppressing relevance maps. In contrast, (Ghorbani et al. (2019)) misleads the relevance maps while keeping the prediction unchanged. (Zhang et al. (2020)) also misleads DNNs, but it keeps the relevance maps unchanged. ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "3 RELEVANCE ATTACK ON DETECTORS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            516,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose an attack specifically designed for black-box transferability, named Relevance Attack on Detectors (RAD). RAD suppresses multi-node relevance maps for several bounding boxes. Since the relevance map is commonly shared by different detectors as shown in Fig. 1, attacking on it in the white-box surrogate model achieves a high transferability towards black-box models. In this section, we first provide a high-level overview of RAD, and analyze the potential reasons of its transferability. Then we thoroughly discuss three crucial concrete issues in RAD. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "• In Section 3.3, we specify the calculation of relevance maps for detectors, where current visualization methods are not applicable.   \n• In Section 3.4, we introduce the proper nodes to attack by RAD.   \n• In Section 3.5, we explore on the suitable techniques to update samples in RAD. ",
+        "bbox": [
+            215,
+            228,
+            825,
+            295
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 WHAT IS RAD? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            310,
+            326,
+            325
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We present the framework of RAD in Fig. 2. Initialized by the original sample $x _ { 0 }$ , the adversarial sample $x _ { k }$ in the $k ^ { \\mathrm { { t h } } }$ iteration is forward propagated in the surrogate model, getting the prediction $f ( x _ { k } )$ . Current attacks generally suppress the prediction values of all attacked output nodes in $T$ . In contrast, RAD suppresses the corresponding relevance map $h ( \\boldsymbol { x } _ { k } , T )$ . To restrain that, gradients of $h ( \\boldsymbol { x } _ { k } , T )$ back propagate to $x _ { k }$ , which is then modified to $x _ { k + 1 }$ . ",
+        "bbox": [
+            174,
+            337,
+            825,
+            407
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/d176c9609254b18a9a20a0467bc55eedcff17b807a627c6824363aab7ff06f3a.jpg",
+        "image_caption": [
+            "Figure 2: Framework of RAD. $x _ { k }$ is the sample in iteration $k$ and $f ( x _ { k } )$ is the network prediction for it. $h ( \\boldsymbol { x } _ { k } , T )$ stands for the relevance map for all attacked nodes in $T$ . RAD works by repeating processes denoted by “black”, “red” and “blue” arrows in turn. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            421,
+            792,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "It is notable that RAD is a complete framework to attack detectors, and its each component requires a special design. Besides the calculation of relevance maps of detectors, other components in RAD, e.g., the attacked nodes or the update techniques, also need a customized analysis. The reason is that no existing work directly attacks the relevance of detectors, and the experience in attacking predictions is not totally applicable here. For example, (Zhang & Wang (2019)) emphasizes classification loss and localization loss equally, but the former is validated to be significantly better in attacking the relevance in Section 3.4. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 WHY RAD TRANSFERS? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            387,
+            828
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "RAD’s transferability comes from the attack goal: changing the common properties, i.e., the relevance maps. As shown in Fig. 3, the relevance maps are clear and structured for the original sample in both detectors. After RAD, the relevance maps are induced to be meaningless without a correct focus, leading to wrong predictions, i.e., no or false detection. Because relevance maps transfer well across models, those for black-box detectors are also significantly influenced, causing a great performance drop, which is illustrated visually in Section 4.2. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/249f41e82d757b53efe52a9a203cba6c688813a5d70a898f39c29cb9afebf958.jpg",
+        "image_caption": [
+            "Figure 3: RAD’s transferability origins from the change of relevance maps. The image contains a person and a skateboard. By attacking on relevance maps, both surrogate models make extremely confusing predictions. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            823,
+            218
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "RAD also attacks quite “precisely”, i.e., the perturbation pattern is significantly focused on distinct areas and has a clear structure as shown in Fig. 4. That is to say, RAD accurately locates the most discriminating parts of a sample and concentrates the perturbation on them, leading to a great transferability when the perturbations is equally bounded. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            354
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/63ab5ec8395fab7e9a3955a560451309ecf40525acdc32dadc207a0abe714629.jpg",
+        "image_caption": [
+            "Figure 4: The original image and the adversarial perturbations $\\times 5$ in magnitude for demonstration) generated by Dfool (Lu et al. (2017)), DAG (Xie et al. (2017)), and RAD (from left to right) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            367,
+            816,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 WHAT IS THE RELEVANCE MAPS FOR DETECTORS? ",
+        "bbox": [
+            174,
+            525,
+            571,
+            540
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We analyze the potential of RAD above, below we make it feasible by addressing three crucial issues.   \nTo conduct the relevance attack, we first need to know the relevance maps for detectors. ",
+        "bbox": [
+            173,
+            551,
+            825,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Currently, there have been lots of methods to calculate the relevance maps for classifiers as described in Section 2, but none of them are suitable for detectors. We take SGLRP (Iwana et al. (2019)) as an example to explain this and then to modify, because it excels in discriminating ability against irrelevant regions of a certain target node. ",
+        "bbox": [
+            174,
+            587,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "SGLRP visualizes how the input contributes to one output node in a pixel-wise way by backpropagating the relevance from the output to the input based on Deep Taylor Decomposition (DTD) as illustrated in Appendix A. $R ^ { ( L ) }$ is the initial relevance in the output layer $L$ and its $n ^ { \\mathrm { t h } }$ component is calculated as ",
+        "bbox": [
+            173,
+            648,
+            825,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21b4b72592d5b4f32af9421fe28ef87051480e5575f7ddd21c77183f2ae017a4.jpg",
+        "text": "$$\nR _ { n } ^ { ( L ) } = { \\left\\{ \\begin{array} { l l } { y _ { n } \\left( 1 - y _ { n } \\right) } & { n = t , } \\\\ { - y _ { n } y _ { t } } & { n \\neq t , } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            708,
+            584,
+            743
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { n }$ is the predicted probability of class $n$ , and $y _ { t }$ is that for the single-node target $t$ . The pixel-wise relevance map $h ( x , t )$ for the single-node target $t$ is calculated by back propagating the relevance $R$ from the final layer to the input following rules specified in (Iwana et al. (2019)). ",
+        "bbox": [
+            174,
+            747,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In detectors, we need the pixel-wise contributions from the input to $m$ bounding boxes. This multi-node relevance map could not be directly calculated by (1), so we naturally modify SGLRP as ",
+        "bbox": [
+            173,
+            796,
+            823,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efc65806449b9288a2eada618cef625c4972cfcf52b140ba28c0676e4cffdff7.jpg",
+        "text": "$$\nR _ { n } ^ { ( L ) } = \\left\\{ \\begin{array} { l l } { y _ { n } \\left( 1 - y _ { n } \\right) } & { n \\in T , } \\\\ { - \\frac { 1 } { m } y _ { n } \\sum _ { i = 1 } ^ { m } y _ { t _ { i } } } & { n \\notin T , } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            354,
+            829,
+            602,
+            864
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $y _ { t _ { i } }$ is the predicted probabilities for one target node $t _ { i }$ . $T$ is the set containing all target nodes $\\{ t _ { 1 } , t _ { 2 } , . . . , t _ { m } \\}$ . With iNNvestigate Library (Alber et al. (2019)) to implement Multi-Node SGLRP and Deep Learning platforms supporting auto-gradient, the gradients from RAD loss $L _ { \\mathrm { R A D } } ( x ) = h ( x , T )$ to sample $x$ could be obtained according to the calculation rules of relevance maps in Appendix A. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We illustrate the difference between SGLRP and our Multi-Node SGLRP in Fig. 5. SGLRP only displays the relevance map for one bounding box, e.g., “TV”, “chair” and “bottle”. Multi- Node SGLRP, in contrast, visualizes the overall relevance. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a45412ecf81682fd77f346e329b0e1b5ce65e40a7e142423efbe4588b2d04216.jpg",
+        "image_caption": [
+            "Figure 5: Difference between relevance maps from SGLRP and Multi-Node SGLRP. The relevance maps are for YOLOv3 (Redmon & Farhadi (2018)). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            161,
+            823,
+            246
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 WHERE TO ATTACK? ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            324,
+            359,
+            338
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Besides the calculation of relevance maps, it is also important to choose a proper node set $T$ to attack.   \nSpecifically, we need to select certain bounding boxes and the corresponding output nodes for RAD. ",
+        "bbox": [
+            176,
+            351,
+            825,
+            380
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Heuristically, the most “obvious” bounding boxes are desired to be eliminated, so we select the bounding boxes with the highest confidence, following (Xie et al. (2017)). Concretely, it is feasible to statically choose $m$ bounding boxes to attack in each iteration, or dynamically attack all bounding boxes whose confidence exceeds a threshold. In our evaluation, the two strategies differ a little in performance and are not sensitive to hyper-parameter as demonstrated in Appendix C. This shows that RAD does not require a sophisticated tuning of parameters, which is user-friendly. In our following experiments, we statically attack $m = 2 0$ nodes. ",
+        "bbox": [
+            174,
+            386,
+            825,
+            483
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After selecting bounding boxes, we could attack their size, leading them to shrink; or their localization, leading them to shift; or their confidence, leading them to be misclassified. To adopt the best strategy, we conduct a toy experiment by attacking YOLOv3 (Redmon & Farhadi (2018)), denoted as M2 and other models are specified in Appendix B. Given the results in Table 1, the classification loss induces a better black-box transferability. This may because detectors generally include a pre-trained classification as the feature extractor, and relevance maps are believed to be an indicator of success attacks (Dong et al. (2019); Zhang & Zhu (2019)). ",
+        "bbox": [
+            173,
+            489,
+            825,
+            588
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/c767a26cf0f5c35c5427e7d1bed8dbc75b75f623ec4633302e1627317108d2a0.jpg",
+        "table_caption": [
+            "Table 1: Detection mAP in RAD with different attacked nodes "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Strategy</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>No Attack</td><td>29.3</td><td>33.4</td><td>38.1</td><td>40.7</td><td>42.1</td><td>42.5</td><td>45.7</td><td>46.9</td><td>53.9</td></tr><tr><td>Size</td><td>26.0</td><td>14.7</td><td>31.9</td><td>32.5</td><td>35.6</td><td>35.4</td><td>38.6</td><td>40.0</td><td>47.8</td></tr><tr><td>Localization</td><td>22.8</td><td>6.4</td><td>27.4</td><td>28.1</td><td>31.7</td><td>30.8</td><td>34.4</td><td>35.9</td><td>45.1</td></tr><tr><td>Classification</td><td>18.1</td><td>1.2</td><td>19.9</td><td>20.5</td><td>24.3</td><td>22.6</td><td>26.4</td><td>28.2</td><td>39.9</td></tr></table>",
+        "bbox": [
+            227,
+            627,
+            772,
+            705
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 HOW TO UPDATE? ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            732,
+            343,
+            747
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "By the relevance map $h ( x , T )$ for certain attacked nodes $T$ , we are able to attack, i.e., update the original sample to become adversarial with the guidance of the attack gradients $g ( x )$ as ",
+        "bbox": [
+            173,
+            758,
+            825,
+            787
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/908cde9228a27c393302593ca6eb1b6d43ccc61fe8c1a8dc949cdfa04891774d.jpg",
+        "text": "$$\ng ( x ) = \\frac { \\partial L _ { \\mathrm { R A D } } ( x ) } { \\partial x } = \\frac { \\partial h ( x , T ) } { \\partial x } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            795,
+            591,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Some update techniques are validated to be effective for enhancing the transferability in classification. For example, Scale-Invariant (SI) (Lin et al. (2020)) proposes to average the attack gradients by scale copies of the samples as ",
+        "bbox": [
+            174,
+            834,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb1d486432461ae9cd62c33643a48397fd58a2503eaddf2481fdb75e3d7d8897.jpg",
+        "text": "$$\ng _ { \\mathrm { s i } } ( x ) = \\frac { 1 } { k } \\sum _ { i = 0 } ^ { k } g ( x / 2 ^ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            885,
+            565,
+            928
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Besides SI, Diverse Input (DI) (Xie et al. (2019)), Translation-Invariant (TI) (Dong et al. (2019)) are also promising in classification. We are curious about whether they also work well in object detection. To explore on this, we adopt these techniques in RAD as the setting suggested by their designers (see Appendix E). From the results in Table 2, we discover that SI is quite effective, further decreasing the mAP from the baseline to a large extent. Accordingly, we adopt (4) to update the sample in RAD. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/adc2a43837c9a0039aade4f063c266be54ba3d23fe7e2b926ada19fd1a9ff9bf.jpg",
+        "table_caption": [
+            "Table 2: Detection mAP in RAD with different update techniques "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Technique</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>None</td><td>18.1</td><td>1.2</td><td>19.9</td><td>20.5</td><td>24.3</td><td>22.6</td><td>26.4</td><td>28.2</td><td>39.9</td></tr><tr><td>DI</td><td>18.1</td><td>1.0</td><td>19.9</td><td>20.5</td><td>23.9</td><td>22.4</td><td>26.3</td><td>27.9</td><td>39.6</td></tr><tr><td>TI</td><td>17.0</td><td>2.4</td><td>20.8</td><td>20.8</td><td>25.2</td><td>23.0</td><td>27.9</td><td>29.7</td><td>41.5</td></tr><tr><td>SI</td><td>14.6</td><td>0.7</td><td>16.3</td><td>17.0</td><td>20.4</td><td>19.1</td><td>22.3</td><td>23.8</td><td>35.0</td></tr></table>",
+        "bbox": [
+            240,
+            210,
+            758,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "With the calculated gradient, we update the sample as ",
+        "bbox": [
+            174,
+            300,
+            526,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82ffc1caee743e11e114e7cc5d70b16df5b364b9b9b39c4b3165290764129613.jpg",
+        "text": "$$\nx _ { k + 1 } = \\mathrm { c l i p } _ { \\varepsilon } \\left( x _ { k } - \\alpha \\frac { g _ { \\mathrm { s i } } ( x _ { k } ) } { | | g _ { \\mathrm { s i } } ( x _ { k } ) | | _ { 1 } / N } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            339,
+            315,
+            609,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ stands for the step length. $x$ is $\\ell _ { \\infty }$ -norm bounded by $\\varepsilon$ from the original sample in each iteration as in (Xie et al. (2019); Dong et al. (2019); Lin et al. (2020)). Gradient $g ( x )$ is normalized by its average $\\ell _ { 1 }$ -norm,i.e., $| | g ( x ) | | _ { 1 } / N$ to prevent numerical errors and control the degree of perturbations. $N$ is the dimension of the image, i.e., $N = h e i g h t \\times w i d t h \\times c h a n n e l .$ Division by $N$ is necessary because $\\ell _ { 1 }$ -norm sums all components of the tensor $x$ , which is too large as a normalization factor. We do not adopt the mainstream sign method because it is not suitable to generate small perturbations as shown in other attacks in detectors (Xie et al. (2017)). ",
+        "bbox": [
+            173,
+            351,
+            825,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            467,
+            326,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the performance of RAD, especially its transferability. The results are presented numerically and visually. In comprehensive evaluation, RAD achieves a great transferability in across models and even across tasks. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            539
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            555,
+            261,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our experiments are based on Keras (Chollet et al. (2015)), Tensorflow (Abadi et al. (2015)) and PyTorch (Paszke et al. (2019)) in 4 NVIDIA GeForce RTX 2080Ti GPUs. Library iNNvestigate (Alber et al. (2019)) is used to implement Multi-Node SGLRP. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments on MS COCO 2017 dataset (Lin et al. (2014)), which is a large-scale benchmark for object detection, instance segmentation and image captioning. For a fair evaluation, we generate adversarial samples from all 5K samples in its validation set and test several black-box models on their mAP, a standard criteria in many works (He et al. (2017); Chen et al. (2019a)). ",
+        "bbox": [
+            174,
+            630,
+            825,
+            686
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "All attacks are conducted with the step length $\\alpha = 2$ for 10 iterations and the perturbation is $\\ell _ { \\infty }$ - bounded in $\\varepsilon = 1 6$ to guarantee the imperceptibility as in (Dong et al. (2019)). To validate that the mAP drop comes from the attack instead of resizing or perturbation, we add large Gaussian noises $( \\sigma = 9$ ) to the resized images, and report it as “Ablation”. ",
+        "bbox": [
+            174,
+            693,
+            825,
+            750
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We choose 8 typical detectors ranging from the first end-to-end detector to recent ones for attack and test. The variety of model guarantees the validity of results. We specify their information in Appendix B and the corresponding pre-processing in Appendix E. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 VISUAL RESULTS OF RAD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            814,
+            400,
+            828
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We visualize several predictions on the same adversarial sample by black-box models in Fig. 6 to intuitively illustrate the transferability of RAD. The objects in the image, e.g., the laptop and keyboard, are quite large and obvious to detect. However, with a small perturbation from RAD, 5 black-box models all fail to detect the laptop, keyboard and mouse. Surprisingly, 4 of them even detect a non-existent “bed”, which is neither relevant nor similar in the image. The attack process of RAD is analyzed in Appendix F. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/f3ddcdba9a9215b81c2eaf82d628a1c96039b1c11d3762d6ba4245add204ea1f.jpg",
+        "image_caption": [
+            "Figure 6: RAD has a great transferability. The same adversarial sample generated by attacking Mask R-CNN fools all 5 black-box detectors. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            103,
+            789,
+            359
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 RAD’S TRANSFERABILITY IN OBJECT DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            433,
+            568,
+            446
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the in-domain transferability of detection attacks and cross-domain transferability of classification attacks, we test the detection mAP of 8 models in COCO adversarial samples generated in the same setting. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            503
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For detection attacks, adversarial samples are crafted by attacking surrogate model M2 (YOLOv3 Redmon & Farhadi (2018)). Results of attacking other surrogates are reported in Appendix D. For classification attacks, we use the model output on the clean sample as the label. By several state-of-the-art attacks on surrogate classifiers (InceptionV3 Szegedy et al. (2016) here as in Xie et al. (2019); Dong et al. (2019)), the adversarial samples are generated and tested the mAP as the transferability towards detectors. Details of implementation are described in Appendix E. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We present the results in Table 3. Among the classification attacks and detection ones, cross-domain attack (Naseer et al. (2019)) is effective, but RAD is more aggressive. RAD enjoys a state-of-theart transferability towards most black-box models, outperforming other methods for above $20 \\%$ . The detection mAPs are more than halved, making state-of-the-art detectors worse than the early single-shot detector (SSD Liu et al. (2016), M1). ",
+        "bbox": [
+            173,
+            601,
+            825,
+            671
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/64c54163701c888624c3b69658d7d40a5ac1905caf669a42d17072c304abcf79.jpg",
+        "table_caption": [
+            "Table 3: Detection mAP in different attacks "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Method</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>Reference</td><td>No Attack Ablation</td><td>29.3 24.9</td><td>33.4 31.4</td><td>38.1 31.2</td><td>40.7 31.6</td><td>42.1 35.0</td><td>42.5 34.3</td><td>45.7 37.5</td><td>46.9 38.8</td><td>53.9 48.6</td></tr><tr><td rowspan=\"4\">Classification Attack</td><td>PGD SI-PGD</td><td>26.4 27.5</td><td>30.4 31.6</td><td>34.4 36.1</td><td>35.4 37.1</td><td>38.4</td><td>38.3</td><td>41.7</td><td>43.1</td><td>51.1</td></tr><tr><td>MI-DI-PGD</td><td>22.9</td><td>26.2</td><td></td><td></td><td>40.0</td><td>40.1</td><td>43.5</td><td>44.8</td><td>52.4</td></tr><tr><td>MI-TI-PGD</td><td></td><td></td><td>29.3</td><td>30.0</td><td>33.2</td><td>32.1</td><td>36.0</td><td>37.5</td><td>48.0</td></tr><tr><td>CD-painting</td><td>20.1 16.4</td><td>23.7 20.8</td><td>24.9 21.3</td><td>25.4 22.8</td><td>30.1 26.6</td><td>27.4 24.5</td><td>32.8 28.9</td><td>34.5 29.5</td><td>47.1 42.3</td></tr><tr><td rowspan=\"3\">Detection Attack</td><td>CD-comics</td><td>16.6</td><td>21.6</td><td>21.7</td><td>22.7</td><td>26.8</td><td>24.3</td><td>29.1</td><td>42.3</td><td>43.7</td></tr><tr><td>Dfool</td><td>23.3</td><td>2.5</td><td>29.2</td><td>29.8</td><td>33.3</td><td>32.9</td><td>36.5</td><td>38.0</td><td>47.5</td></tr><tr><td>Loc DAG</td><td>21.9 20.8</td><td>0.2</td><td>25.8</td><td>26.6</td><td>29.8</td><td>29.4</td><td>33.2</td><td>33.2</td><td>45.2</td></tr><tr><td>Ours</td><td>RAD</td><td>14.6</td><td>0.6 0.7</td><td>22.8 16.3</td><td>23.4 17.0</td><td>26.8 20.4</td><td>25.6 19.1</td><td>28.9 22.3</td><td>31.0 23.8</td><td>40.6 35.0</td></tr></table>",
+        "bbox": [
+            176,
+            713,
+            823,
+            921
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The influence of $\\varepsilon$ on detection mAP in RAD are displayed in Fig. 7. With the $\\ell _ { \\infty }$ bound increases, the resulting mAP greatly decreases for all black-box models especially for $\\varepsilon$ from 8 to 12. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a2da1b2cd3f09b13287065c5673de5c813feaeb1b97bca2660057b3e05804b22.jpg",
+        "image_caption": [
+            "Figure 7: The influence of $\\varepsilon$ on detection mAP in RAD "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            222,
+            167,
+            763,
+            349
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 RAD’S TRANSFERABILITY TO INSTANCE SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            414,
+            614,
+            429
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Detection and segmentation are similar in some aspects, so they could be implemented in one network (He et al. (2017); Cai & Vasconcelos (2018); Chen et al. (2019a)). Also, adversarial samples for object detection tend to transfer to instance segmentation (Xie et al. (2017)). Accordingly, we evaluate this cross-task transferability by RAD on surrogate detectors YOLOv3 (Redmon & Farhadi (2018), M2), RetinaNet (Lin et al. (2017), M3) and Mask R-CNN (He et al. (2017), M5). From the results in Table 4, we find that RAD also greatly hurts the performance of instance segmentation, leading to a drop on mAP of over $70 \\%$ . This inspire the segmentation attackers to indirectly attack detectors. ",
+        "bbox": [
+            174,
+            440,
+            826,
+            539
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/49aae684a13002d7040dbc5a1e5f490d645fcf147b3120800b92789aeb5bbf05.jpg",
+        "table_caption": [
+            "Table 4: Segmentation mAP of RAD "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"2\">mAP</td><td colspan=\"2\">mAP50</td><td colspan=\"2\"></td><td colspan=\"2\">mAP75</td><td></td></tr><tr><td> Surrogate</td><td>M5</td><td>M7</td><td>M8</td><td>M5</td><td>M7</td><td>M8</td><td>M5</td><td>M7</td><td>M8</td></tr><tr><td>None</td><td>38.0</td><td>39.4</td><td>40.8</td><td>60.6</td><td>61.3</td><td>63.3</td><td>40.9</td><td>42.9</td><td>44.1</td></tr><tr><td>Ablation</td><td>31.0</td><td>31.9</td><td>33.5</td><td>51.2</td><td>51.0</td><td>53.7</td><td>32.4</td><td>34.3</td><td>35.4</td></tr><tr><td>M2</td><td>17.9</td><td>18.6</td><td>20.3</td><td>31.6</td><td>31.7</td><td>34.5</td><td>18.0</td><td>18.9</td><td>20.7</td></tr><tr><td>M3</td><td>11.6</td><td>11.9</td><td>12.9</td><td>19.2</td><td>19.1</td><td>20.7</td><td>12.1</td><td>12.6</td><td>13.7</td></tr><tr><td>M5</td><td>1.2</td><td>11.1</td><td>11.8</td><td>2.4</td><td>17.9</td><td>18.9</td><td>1.0</td><td>11.9</td><td>12.6</td></tr></table>",
+        "bbox": [
+            238,
+            579,
+            759,
+            691
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 ADVERSARIAL OBJECTS IN CONTEXT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            731,
+            519,
+            747
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Given the great transferability of RAD, we create Adversarial Objects in COntext (AOCO), the first adversarial dataset for object detection. AOCO dataset serves as a potential benchmark to evaluate the robustness of detectors, which will be beneficial to network designers. It will also be useful for adversarial training, as the most effective practice to improve the robustness of DNNs Zhang et al. (2019); Tramèr et al. (2018). Notice that there is no other adversarial dataset for detection at all. This is not because the dataset is useless, but due to the low transferability of attack methods such that the examples are detector-dependent. Now we have achieved high transferability and can then make such an adversarial dataset publicly available. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "AOCO is generated from the full COCO 2017 validation set (Lin et al. (2014)) with $5 \\mathrm { k }$ samples. It contains 5K adversarial samples for evaluating object detection (AOCO detection) and 5K for instance segmentation (AOCO segmentation). All 10K samples in AOCO are crafted by RAD. The surrogate model we attack is YOLOv3 for AOCO detection and Mask R-CNN for AOCO segmentation given the results in Table 3 and Table 4. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We measure the perturbation $\\Delta x$ in AOCO by Root Mean Squared Error (RMSE) as in (Xie et al. (2017); Liu et al. (2017)). It is calculated as $\\sqrt { \\textstyle \\sum _ { i } ( \\Delta x _ { i } ) ^ { 2 } / N }$ in a pixel-wise way, and $N$ is the size of the image. Performance of AOCO is reported in Table 5. The RMSE in AOCO is lower than that in (Wu et al. (2019)), and the perturbation is quite imperceptible. Details and samples of AOCO are presented in Appendix G. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            210
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/a3dcc4468df73135dd0cf3646c751336cf1e68991f4a49ee3fcd2e5d387f6060.jpg",
+        "table_caption": [
+            "Table 5: Detection mAP and segmentation mAP on COCO and AOCO "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>RMSE</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>COCO detection AOCO detection</td><td>0.000 6.469</td><td>29.3 14.6</td><td>33.4 0.7</td><td>38.1 16.3</td><td>40.7 17</td><td>42.1 20.4</td><td>42.5 19.1</td><td>45.7 22.3</td><td>46.9 23.8</td><td>53.9 35.0</td></tr><tr><td>COCO segmentation</td><td>0.000</td><td>N</td><td></td><td></td><td></td><td>38.0</td><td></td><td>39.4</td><td>40.8</td><td>\\\\</td></tr><tr><td> AOCO segmentation</td><td>6.606</td><td></td><td>广</td><td>广</td><td>\\\\</td><td>1.2</td><td>一</td><td>11.1</td><td>11.8</td><td></td></tr></table>",
+        "bbox": [
+            173,
+            248,
+            828,
+            333
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            318,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To pursue a high transferability, this paper proposes Relevance Attack on Detectors (RAD), which works by suppressing the multi-node relevance, a common property across detectors calculated by our Multi-Node SGLRP. We also thoroughly discuss where to attack and the how to update in attacking relevance maps. RAD achieves a state-of-the-art transferability towards 8 diverse black-box models, exceeding existing results by above $20 \\%$ , and also significantly hurts the instance segmentation. Given the great transferability of RAD, we generate the first adversarial dataset for object detection, i.e., Adversarial Objects in COntext (AOCO), which helps to quickly evaluate and improve the robustness of detectors. Also, attacking other common properties is promising for a good transferability. ",
+        "bbox": [
+            173,
+            395,
+            826,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            527,
+            285,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Jozefowicz, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dandelion Mané, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viégas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale machine learning on heterogeneous systems, 2015. URL https://www.tensorflow.org/. Software available from tensorflow.org. ",
+        "bbox": [
+            176,
+            549,
+            826,
+            675
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Maximilian Alber, Sebastian Lapuschkin, Philipp Seegerer, Miriam Hägele, Kristof T Schütt, Gré- goire Montavon, Wojciech Samek, Klaus-Robert Müller, Sven Dähne, and Pieter-Jan Kindermans. innvestigate neural networks. Journal of Machine Learning Research, 20(93):1–8, 2019. ",
+        "bbox": [
+            174,
+            683,
+            826,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sebastian Bach, Alexander Binder, Grégoire Montavon, Frederick Klauschen, Klaus-Robert Müller, and Wojciech Samek. On pixel-wise explanations for non-linear classifier decisions by layer-wise relevance propagation. PloS one, 10(7), 2015. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            775
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shumeet Baluja and Ian Fischer. Adversarial transformation networks: Learning to generate adversarial examples. arXiv preprint arXiv:1703.09387, 2017. ",
+        "bbox": [
+            173,
+            781,
+            823,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wieland Brendel, Jonas Rauber, and Matthias Bethge. Decision-based adversarial attacks: Reliable attacks against black-box machine learning models. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings, 2018. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhaowei Cai and Nuno Vasconcelos. Cascade r-cnn: Delving into high quality object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6154–6162, 2018. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy $( S P )$ , pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            169,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Chen, Jiangmiao Pang, Jiaqi Wang, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jianping Shi, Wanli Ouyang, et al. Hybrid task cascade for instance segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4974–4983, 2019a. ",
+        "bbox": [
+            174,
+            140,
+            826,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Chen, Jiaqi Wang, Jiangmiao Pang, Yuhang Cao, Yu Xiong, Xiaoxiao Li, Shuyang Sun, Wansen Feng, Ziwei Liu, Jiarui Xu, et al. Mmdetection: Open mmlab detection toolbox and benchmark. arXiv preprint arXiv:1906.07155, 2019b. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sizhe Chen, Zhengbao He, Chengjin Sun, and Xiaolin Huang. Universal adversarial attack on attention and the resulting dataset damagenet. arXiv preprint arXiv:2001.06325, 2020. ",
+        "bbox": [
+            174,
+            257,
+            821,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "François Chollet et al. Keras. https://keras.io, 2015. ",
+        "bbox": [
+            173,
+            295,
+            575,
+            310
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinpeng Dong, Fangzhou Liao, Tianyu Pang, Hang Su, Jun Zhu, Xiaolin Hu, and Jianguo Li. Boosting adversarial attacks with momentum. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 9185–9193, 2018. ",
+        "bbox": [
+            176,
+            319,
+            826,
+            362
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yinpeng Dong, Tianyu Pang, Hang Su, and Jun Zhu. Evading defenses to transferable adversarial examples by translation-invariant attacks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4312–4321, 2019. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amirata Ghorbani, Abubakar Abid, and James Zou. Interpretation of neural networks is fragile. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 33, pp. 3681–3688, 2019. ",
+        "bbox": [
+            173,
+            421,
+            823,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. STAT, 1050:20, 2015. ",
+        "bbox": [
+            173,
+            459,
+            823,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jindong Gu, Yinchong Yang, and Volker Tresp. Understanding individual decisions of cnns via contrastive backpropagation. In Asian Conference on Computer Vision, pp. 119–134. Springer, 2018. ",
+        "bbox": [
+            173,
+            497,
+            826,
+            539
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Georgia Gkioxari, Piotr Dollár, and Ross Girshick. Mask r-cnn. In Proceedings of the IEEE international conference on computer vision, pp. 2961–2969, 2017. ",
+        "bbox": [
+            173,
+            547,
+            823,
+            578
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lifeng Huang, Chengying Gao, Yuyin Zhou, Cihang Xie, Alan L Yuille, Changqing Zou, and Ning Liu. Universal physical camouflage attacks on object detectors. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 720–729, 2020. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Brian Kenji Iwana, Ryohei Kuroki, and Seiichi Uchida. Explaining convolutional neural networks using softmax gradient layer-wise relevance propagation. In 2019 IEEE/CVF International Conference on Computer Vision Workshops, ICCV Workshops 2019, Seoul, Korea (South), October 27-28, 2019, 2019. ",
+        "bbox": [
+            174,
+            637,
+            825,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuezun Li, Xian Bian, and Siwei Lyu. Attacking object detectors via imperceptible patches on background. CoRR, abs/1809.05966, 2018a. ",
+        "bbox": [
+            171,
+            703,
+            823,
+            732
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuezun Li, Xiao Bian, Ming-Ching Chang, and Siwei Lyu. Exploring the vulnerability of single shot module in object detectors via imperceptible background patches. In 30th British Machine Vision Conference 2019, BMVC 2019, Cardiff, UK, September 9-12, 2019, 2018b. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            784
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuezun Li, Daniel Tian, Xiao Bian, Siwei Lyu, et al. Robust adversarial perturbation on deep proposal-based models. 2018c. ",
+        "bbox": [
+            169,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiadong Lin, Chuanbiao Song, Kun He, Liwei Wang, and John E Hopcroft. Nesterov accelerated gradient and scale invariance for adversarial attacks. In 8th International Conference on Learning Representations, ICLR, 2020. ",
+        "bbox": [
+            174,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Michael Maire, Serge Belongie, James Hays, Pietro Perona, Deva Ramanan, Piotr Dollár, and C Lawrence Zitnick. Microsoft coco: Common objects in context. In European Conference on Computer Vision, pp. 740–755. Springer, 2014. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tsung-Yi Lin, Priya Goyal, Ross Girshick, Kaiming He, and Piotr Dollár. Focal loss for dense object detection. In Proceedings of the IEEE international conference on computer vision, pp. 2980–2988, 2017. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Liu, Dragomir Anguelov, Dumitru Erhan, Christian Szegedy, Scott Reed, Cheng-Yang Fu, and Alexander C Berg. Ssd: Single shot multibox detector. In European Conference on Computer Vision, pp. 21–37. Springer, 2016. ",
+        "bbox": [
+            174,
+            156,
+            826,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. In Proceedings of 5th International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            174,
+            208,
+            826,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiajun Lu, Hussein Sibai, and Evan Fabry. Adversarial examples that fool detectors. arXiv preprint arXiv:1712.02494, 2017. ",
+        "bbox": [
+            173,
+            261,
+            823,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Aleksander M ˛adry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. STAT, 1050:9, 2017. ",
+        "bbox": [
+            171,
+            300,
+            823,
+            330
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Muhammad Muzammal Naseer, Salman H Khan, Muhammad Haris Khan, Fahad Shahbaz Khan, and Fatih Porikli. Cross-domain transferability of adversarial perturbations. In Advances in Neural Information Processing Systems, pp. 12905–12915, 2019. ",
+        "bbox": [
+            174,
+            339,
+            825,
+            383
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, and Ian Goodfellow. Transferability in machine learning: from phenomena to black-box attacks using adversarial samples. arXiv preprint arXiv:1605.07277, 2016. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            434
+        ],
+        "page_idx": 10
+    },
+    {
+        "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, 2017. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            488
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. In Advances in Neural Information Processing Systems, pp. 8024–8035, 2019. ",
+        "bbox": [
+            173,
+            497,
+            826,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joseph Redmon and Ali Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018. ",
+        "bbox": [
+            171,
+            564,
+            825,
+            593
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shaoqing Ren, Kaiming He, Ross Girshick, and Jian Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. In Advances in Neural Information Processing Systems, pp. 91–99, 2015. ",
+        "bbox": [
+            174,
+            603,
+            825,
+            646
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ramprasaath R Selvaraju, Michael Cogswell, Abhishek Das, Ramakrishna Vedantam, Devi Parikh, and Dhruv Batra. Grad-cam: Visual explanations from deep networks via gradient-based localization. In Proceedings of the IEEE International Conference on Computer Vision, pp. 618–626, 2017. ",
+        "bbox": [
+            174,
+            656,
+            826,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Avanti Shrikumar, Peyton Greenside, and Anshul Kundaje. Learning important features through propagating activation differences. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3145–3153. JMLR. org, 2017. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            766
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dong Su, Huan Zhang, Hongge Chen, Jinfeng Yi, Pin-Yu Chen, and Yupeng Gao. Is robustness the cost of accuracy?–a comprehensive study on the robustness of 18 deep image classification models. In Proceedings of the European Conference on Computer Vision (ECCV), 2018. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            819
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jiawei Su, Danilo Vasconcellos Vargas, and Kouichi Sakurai. One pixel attack for fooling deep neural networks. IEEE Transactions on Evolutionary Computation, 2019. ",
+        "bbox": [
+            169,
+            828,
+            823,
+            858
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, 2014. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Vincent Vanhoucke, Sergey Ioffe, Jon Shlens, and Zbigniew Wojna. Rethinking the inception architecture for computer vision. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2818–2826, 2016. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Mingxing Tan, Ruoming Pang, and Quoc V Le. Efficientdet: Scalable and efficient object detection. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 10781–10790, 2020. ",
+        "bbox": [
+            174,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Simen Thys, Wiebe Van Ranst, and Toon Goedemé. Fooling automated surveillance cameras: adversarial patches to attack person detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops, 2019. ",
+        "bbox": [
+            173,
+            205,
+            826,
+            250
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Florian Tramèr, Alexey Kurakin, Nicolas Papernot, Ian J. Goodfellow, Dan Boneh, and Patrick D. McDaniel. Ensemble adversarial training: Attacks and defenses. In 6th International Conference on Learning Representations, ICLR 2018, Vancouver, BC, Canada, April 30 - May 3, 2018, Conference Track Proceedings, 2018. ",
+        "bbox": [
+            174,
+            257,
+            826,
+            314
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yajie Wang, Yu-an Tan, Wenjiao Zhang, Yuhang Zhao, and Xiaohui Kuang. An adversarial attack on dnn-based black-box object detectors. Journal of Network and Computer Applications, pp. 102634, 2020. ",
+        "bbox": [
+            174,
+            323,
+            826,
+            366
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dongxian Wu, Yisen Wang, Shutao Xia, James Bailey, and Xingjun Ma. Skip connections matter: On the transferability of adversarial examples generated with resnets. In Proceedings of the International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            174,
+            375,
+            826,
+            417
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Weibin Wu, Yuxin Su, Xixian Chen, Shenglin Zhao, Irwin King, Michael R Lyu, and Yu-Wing Tai. Boosting the transferability of adversarial samples via attention. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1161–1170, 2020a. ",
+        "bbox": [
+            178,
+            426,
+            823,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zuxuan Wu, Ser-Nam Lim, Larry S Davis, and Tom Goldstein. Making an invisibility cloak: Real world adversarial attacks on object detectors. In European Conference on Computer Vision, pp. 1–17. Springer, 2020b. ",
+        "bbox": [
+            173,
+            478,
+            825,
+            521
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cihang Xie, Jianyu Wang, Zhishuai Zhang, Yuyin Zhou, Lingxi Xie, and Alan Yuille. Adversarial examples for semantic segmentation and object detection. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1369–1378, 2017. ",
+        "bbox": [
+            176,
+            529,
+            823,
+            573
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Cihang Xie, Zhishuai Zhang, Yuyin Zhou, Song Bai, Jianyu Wang, Zhou Ren, and Alan L Yuille. Improving transferability of adversarial examples with input diversity. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2730–2739, 2019. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            625
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kaidi Xu, Gaoyuan Zhang, Sijia Liu, Quanfu Fan, Mengshu Sun, Hongge Chen, Pin-Yu Chen, Yanzhi Wang, and Xue Lin. Adversarial t-shirt! evading person detectors in a physical world. In European Conference on Computer Vision, pp. 665–681. Springer, 2020. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European Conference on Computer Vision, pp. 818–833. Springer, 2014. ",
+        "bbox": [
+            174,
+            684,
+            823,
+            713
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dinghuai Zhang, Tianyuan Zhang, Yiping Lu, Zhanxing Zhu, and Bin Dong. You only propagate once: Painless adversarial training using maximal principle. arXiv preprint arXiv:1905.00877, 2019. ",
+        "bbox": [
+            173,
+            722,
+            826,
+            763
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Haichao Zhang and Jianyu Wang. Towards adversarially robust object detection. In Proceedings of the IEEE International Conference on Computer Vision, pp. 421–430, 2019. ",
+        "bbox": [
+            171,
+            773,
+            825,
+            803
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tianyuan Zhang and Zhanxing Zhu. Interpreting adversarially trained convolutional neural networks. In Proceedings of the 36th International Conference on Machine Learning, ICML 2019, 9-15 June 2019, Long Beach, California, USA, pp. 7502–7511, 2019. ",
+        "bbox": [
+            176,
+            811,
+            825,
+            854
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xinyang Zhang, Ningfei Wang, Hua Shen, Shouling Ji, Xiapu Luo, and Ting Wang. Interpretable deep learning under fire. In 29th {USENIX} Security Symposium ({USENIX} Security 20), 2020. ",
+        "bbox": [
+            174,
+            863,
+            825,
+            892
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A RELEVANCE BACK-PROPAGATION RULES (DTD) ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            617,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "DTD-based network visualization methods, such as LRP, CLRP and SGLRP, back-propagate the relevance from the output layer to the input layer according to the rules specified in this section. Their only difference is the relevance in the initial output layer $\\bar { R } _ { n } ^ { ( L ) }$ . ",
+        "bbox": [
+            173,
+            132,
+            825,
+            179
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For each layer $l$ in a DNN with $L$ layers in total, suppose layer $l$ has $N$ nodes and layer $l + 1$ has $M$ nodes, the relevance $R _ { n } ^ { ( L ) }$ at node $n$ in layer $l$ is defined recursively by ",
+        "bbox": [
+            174,
+            184,
+            818,
+            217
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15442641a21ca74ad3cc21cd56d1135b3004f8d068a9f48b22e7f6e0e6e85930.jpg",
+        "text": "$$\nR _ { n } ^ { ( l ) } = \\sum _ { m } \\frac { a _ { n } ^ { ( l ) } w _ { n , m } ^ { + ( l ) } } { \\sum _ { n ^ { \\prime } } a _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { + ( l ) } } R _ { m } ^ { ( l + 1 ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            383,
+            218,
+            612,
+            261
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "for nodes with definite positive values (such as after ReLU), and ",
+        "bbox": [
+            173,
+            262,
+            598,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/823983dd93685ea41fcc62e8e68b6449a90866472e8cf5d268d1f7a4a46de264.jpg",
+        "text": "$$\nR _ { n } ^ { ( l ) } = \\sum _ { m } \\frac { z _ { n } ^ { ( l ) } w _ { n , m } ^ { ( l ) } - b _ { n } ^ { ( l ) } w _ { n , m } ^ { + ( l ) } - h _ { n } ^ { ( l ) } w _ { n , m } ^ { - ( l ) } } { \\sum _ { n ^ { \\prime } } z _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { ( l ) } - b _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { + ( l ) } - h _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { - ( l ) } } R _ { m } ^ { ( l + 1 ) } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            277,
+            696,
+            321
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "for nodes that may have negative values. In the formulas above, $a _ { n } ^ { ( l ) }$ is the post-activation output of node in layer $l$ and $z _ { n } ^ { ( l ) }$ is the pre-activation one. The range $[ b _ { n } ^ { ( l ) } , h _ { n } ^ { ( l ) } ]$ stands for the minimum and maximum of $z _ { n } ^ { ( l ) }$ . Finally, $w _ { n , m } ^ { + ( l ) } = \\operatorname* { m a x } \\left( w _ { n , m , 0 } ^ { ( l ) } \\right)$ and $w _ { n , m } ^ { - ( l ) } = \\operatorname* { m i n } \\left( w _ { n , m , 0 } ^ { ( l ) } \\right)$ . ",
+        "bbox": [
+            173,
+            325,
+            826,
+            382
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "According to the propagation rules above as mentioned in (Iwana et al. (2019)), we could naturally obtain the attack gradients as ",
+        "bbox": [
+            173,
+            387,
+            825,
+            416
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/af76ec06ee852865bcca96eb7138334ccbaffc4232acc27e3c3bd671d7376364.jpg",
+        "text": "$$\n\\frac { \\partial R _ { m } ^ { ( l + 1 ) } } { \\partial R _ { n } ^ { ( l ) } } = \\left\\{ \\begin{array} { l l } { \\big ( \\sum _ { m } \\frac { a _ { n } ^ { ( l ) } w _ { n , m } ^ { + ( l ) } } { \\sum _ { n ^ { \\prime } } a _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { + ( l ) } } \\big ) ^ { - 1 } , \\mathrm { f o r ~ n o d e s ~ w i t h ~ d e f i n i t e ~ p o s i t i v e ~ v a l u e s } } \\\\ { \\big ( \\sum _ { m } \\frac { z _ { n } ^ { ( l ) } w _ { n , m } ^ { ( l ) } - b _ { n } ^ { ( l ) } w _ { n , m } ^ { + ( l ) } - h _ { n } ^ { ( l ) } w _ { n , m } ^ { - ( l ) } } { \\sum _ { n ^ { \\prime } } z _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { ( l ) } - b _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { + ( l ) } - h _ { n ^ { \\prime } } ^ { ( l ) } w _ { n ^ { \\prime } , m } ^ { - ( l ) } } \\big ) ^ { - 1 } , \\mathrm { o t h e r w i s e } } \\end{array} \\right. .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            417,
+            764,
+            484
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B MODEL INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            500,
+            398,
+            515
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Table 6 presents the models’ information from our evaluation and MMdetection (Chen et al. (2019b)). ",
+        "bbox": [
+            174,
+            529,
+            825,
+            545
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/bff1424075e1a6794af349ad4ca8f37bedb99d04ff275d86a33691c1d597f5e3.jpg",
+        "table_caption": [
+            "Table 6: Model backbone and mAPs "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>ID</td><td>Model</td><td>Backbone</td><td>mAP</td></tr><tr><td>M1</td><td>SSD512 (Liu et al. (2016))</td><td>VGG16</td><td>29.3</td></tr><tr><td>M2</td><td>YOLOv3 (Redmon &amp; Farhadi (2018))</td><td>Darknet</td><td>33.4</td></tr><tr><td>M3</td><td>RetinaNet (Lin et al. (2017))</td><td>ResNet-101</td><td>38.1</td></tr><tr><td>M4</td><td>Faster R-CNN (Ren et al. (2015))</td><td>ResNeXt-101-64*4d</td><td>40.7</td></tr><tr><td>M5</td><td>Mask R-CNN (He et al. (2017))</td><td>ResNeXt-101-64*4d</td><td>42.1</td></tr><tr><td>M6</td><td>Cascade RCNN (Cai &amp; Vasconcelos (2018))</td><td>ResNet-101</td><td>42.5</td></tr><tr><td>M7</td><td>Cascade Mask R-CNN (Cai &amp; Vasconcelos (2018))</td><td>ResNeXt-101-64*4d</td><td>45.7</td></tr><tr><td>M8</td><td>Hyrbrid Task Cascade (Chen et al. (2019a))</td><td>ResNeXt-101-64*4d</td><td>46.9</td></tr><tr><td>M9</td><td>EfficientDet (Tan et al. (2020))</td><td>EfficientNet+BiFPN</td><td>53.9</td></tr></table>",
+        "bbox": [
+            191,
+            590,
+            807,
+            738
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C INFLUENCE OF HYPER-PARAMETERS IN NODE SELECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            696,
+            789
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Performance of RAD is not sensitive to hyper-parameter, no matter the strategy to select bounding boxes is dynamic or static as Table 7. Attackers are not bothered to tune them carefully. The parameter for dynamic strategy refers to the pre-softmax confidence threshold to select a bounding box. The parameter for static strategy refers to the fixed number of selected bounding boxes in each iteration. ",
+        "bbox": [
+            174,
+            803,
+            825,
+            859
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D RAD ON MORE SURROGATES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            878,
+            459,
+            895
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The results on attacking more surrogates by RAD are reported in Table 8. ",
+        "bbox": [
+            173,
+            909,
+            653,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/1cc4c528e9a27d155647b2c16ea206a19d21b1a140801df2b2428f83dc09f132.jpg",
+        "table_caption": [
+            "Table 7: Detection mAP in different hyper-parameters in RAD "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Strategy</td><td>Parameter</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td rowspan=\"3\">Dynamic</td><td>-1</td><td>18.3</td><td>1.2</td><td>20.0</td><td>20.6</td><td>24.3</td><td>22.8</td><td>26.7</td><td>28.3</td><td>40.0</td></tr><tr><td>-2</td><td>18.2</td><td>1.2</td><td>20.1</td><td>20.7</td><td>24.2</td><td>22.8</td><td>26.6</td><td>28.0</td><td>39.8</td></tr><tr><td>-3</td><td>18.4</td><td>1.3</td><td>20.3</td><td>20.8</td><td>24.3</td><td>22.9</td><td>26.7</td><td>28.5</td><td>40.2</td></tr><tr><td rowspan=\"3\">Static</td><td>10</td><td>18.2</td><td>1.1</td><td>19.9</td><td>20.5</td><td>24.2</td><td>22.8</td><td>26.2</td><td>28.0</td><td>39.8</td></tr><tr><td>20</td><td>18.1</td><td>1.2</td><td>19.9</td><td>20.5</td><td>24.3</td><td>22.6</td><td>26.4</td><td>28.2</td><td>39.9</td></tr><tr><td>30</td><td>18.2</td><td>1.3</td><td>20.1</td><td>20.7</td><td>24.3</td><td>22.8</td><td>26.0</td><td>27.9</td><td>40.1</td></tr></table>",
+        "bbox": [
+            200,
+            127,
+            795,
+            239
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc9e8ad930abc9aee5810359acf2b6628a9e674e6518dccd566d4cd0579310f0.jpg",
+        "table_caption": [
+            "Table 8: Detection mAP of RAD on different surrogates "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td> Surrogate</td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>YOLOv3</td><td>14.6</td><td>0.7</td><td>16.3</td><td>17.0</td><td>20.4</td><td>19.1</td><td>22.3</td><td>23.8</td><td>35.0</td></tr><tr><td>Mask R-CNN</td><td>20.4</td><td>24.2</td><td>25.7</td><td>26.5</td><td>1.1</td><td>28.9</td><td>33.1</td><td>34.9</td><td>45.4</td></tr><tr><td>RetinaNet</td><td>20.7</td><td>6.1</td><td>2.3</td><td>25.7</td><td>29.3</td><td>28.2</td><td>31.7</td><td>33.8</td><td>44.1</td></tr></table>",
+        "bbox": [
+            225,
+            279,
+            772,
+            343
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            366,
+            437,
+            382
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.1 PRE-PROCESSING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            397,
+            338,
+            412
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "To pre-process, we resize the image with its long side as 416 for YOLOv3 or RetinaNet and 448 for Mask R-CNN, and then zero-pad it to a square. The resolution is kept relatively the same for a fair evaluation. Images are normalized to [0,1] in YOLOv3 or subtracted by the mean of COCO training set in RetinaNet and Mask R-CNN. Accordingly, samples in AOCO detection have the long side 416 and that for AOCO segmentation is 448. ",
+        "bbox": [
+            174,
+            424,
+            825,
+            493
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.2 TRANSFER-ENHANCING UPDATE TECHNIQUES",
+        "text_level": 1,
+        "bbox": [
+            174,
+            511,
+            540,
+            525
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "DI (Xie et al. (2019)) transforms the image for 4 times with probability $p$ $\\mathbf { \\boldsymbol { p } } = 1$ for better transferability as suggested) and averaging the gradients. The transformation is to resize the image to $0 . 9 \\times$ its size and randomly padding the outer areas with white pixels. SI (Lin et al. (2020)) divides the sample numerically by the power 2 for 4 times and averages the 4 obtained gradients. TI (Dong et al. (2019)) translates the image to calculate the augmented gradients. To implement it efficiently, it adopts a kernel to simulate the averaging of gradients. We choose the kernel size 15 as suggested. MI (Dong et al. (2018)) uses momentum optimization (parameter $\\mu = 1$ as suggested) for a better transferability and a faster attack. Cross-domain attack (Naseer et al. (2019)) uses extra datasets (paintings, denoted as CD-paintings, and comics, denoted as CD-comics) to train a perturbation generator with the relative loss. The adopted surrogate model is also InceptionV3 for consistency. All perturbations are resized to fit the sample size. ",
+        "bbox": [
+            173,
+            536,
+            825,
+            689
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.3 DETECTION ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            705,
+            367,
+            720
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For DAG (Xie et al. (2017)), we follow the setting of generating dense proposals. The classification probabilities of 3000 bounding boxes with highest confidence are attacked. But we alter its optimization to (5) because its original update produces quite small perturbation, leading to a poor transferability, which is unfair for comparison. Dfool (Lu et al. (2017)) suppresses the classification confidence for the original bounding boxes, which is the same in our experiment. Localization loss is shown to be useful in (Zhang & Wang (2019)), and here we suppress the width and height of the original bounding boxes. ",
+        "bbox": [
+            174,
+            732,
+            825,
+            830
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F VISUAL RESULTS OF RAD PROCESS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            509,
+            866
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "By RAD, the relevance map is attacked to be meaningless and loss its focus. In Fig. 8, the initial prediction is correct and the relevance map is clear. RAD constantly misleads the relevance map to be unstructured without outline of objects. Finally, all bounding boxes vanish. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/95ea87cc03ebb9e5d0232975306185915289b6e281665271ac23ef4ee01c0c56.jpg",
+        "image_caption": [
+            "Figure 8: Transition of prediction and relevance map in RAD (from top to bottom and left to right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            103,
+            821,
+            441
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "G MORE ABOUT AOCO ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            390,
+            513
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We report the mAP50 and mAP75 of AOCO in Table 9 and Table 10. We show in Fig. 9 the visual comparative results. ",
+        "bbox": [
+            176,
+            529,
+            825,
+            558
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/2b6c6f7f5b900d9b3717ba03dcb7c0a20bfc766dec849b698ee17e974725a617.jpg",
+        "table_caption": [
+            "Table 9: Detection mAP50 and segmentation mAP50 on COCO and AOCO "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>COCO detection AOCO detection</td><td>49.2 26.7</td><td>56.4 1.6</td><td>58.1 27.6</td><td>62.0 29.1</td><td>63.8 34.5</td><td>60.7 29.9</td><td>64.1 34.3</td><td>66.0 37.4</td><td>74.3 51.7</td></tr><tr><td>COCO segmentation</td><td></td><td></td><td>人</td><td>一</td><td>60.6</td><td>一</td><td>61.3</td><td>63.3</td><td>一</td></tr><tr><td>AOCO segmentation</td><td></td><td></td><td></td><td></td><td>2.4</td><td>一</td><td>17.9</td><td>18.9</td><td>一</td></tr></table>",
+        "bbox": [
+            204,
+            598,
+            794,
+            683
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/5ab0bdb9f579ad1a17aef01ee8c33398afd562e0655ae1fd1a702808022d01bd.jpg",
+        "table_caption": [
+            "Table 10: Detection mAP75 and segmentation mAP75 on COCO and AOCO "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>M1</td><td>M2</td><td>M3</td><td>M4</td><td>M5</td><td>M6</td><td>M7</td><td>M8</td><td>M9</td></tr><tr><td>COCO detection AOCO detection</td><td>30.8 14.2</td><td>35.8 0.6</td><td>40.6 16.5</td><td>44.6 17.1</td><td>46.3 20.8</td><td>46.3 19.9</td><td>50.0 23.3</td><td>51.2 24.6</td><td>59.9 37.4</td></tr><tr><td>COCO segmentation</td><td></td><td></td><td>/</td><td>/</td><td>40.9</td><td>一</td><td>42.9</td><td>44.1</td><td>一</td></tr><tr><td>AOCO segmentation</td><td></td><td></td><td></td><td></td><td>1.0</td><td>/</td><td>11.9</td><td>12.6</td><td></td></tr></table>",
+        "bbox": [
+            202,
+            736,
+            795,
+            820
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/93f75b8037c78908db07fd96e74d56484522f7c49490b9643c1b77d5e76d509b.jpg",
+        "image_caption": [
+            "Figure 9: Detection and segmentation results in COCO and AOCO by YOLOv3 and Mask R-CNN. For COCO, both networks predict correctly. For AOCO segmentation results, the top image contains two big masks for “chair” and “potted plan”; the second image contains one false mask for “sports ball”; the bottom image contains “dog” in green, “car” in purple and “elephant” in red. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            337,
+            820,
+            608
+        ],
+        "page_idx": 15
+    }
+]

parse/train/j7u7cJDBo8p/j7u7cJDBo8p.md

@@ -0,0 +1,250 @@
+# Referring Transformer: A One-step Approach to Multi-task Visual Grounding
+
+Muchen Li1,2 muchenli@cs.ubc.ca
+
+Leonid Sigal1,2,3,4 lsigal@cs.ubc.ca
+
+1Department of Computer Science, University of British Columbia   
+2Vector Institute for AI 3CIFAR AI Chair 4NSERC CRC Chair
+
+# Abstract
+
+As an important step towards visual reasoning, visual grounding (e.g., phrase localization, referring expression comprehension / segmentation) has been widely explored. Previous approaches to referring expression comprehension (REC) or segmentation (RES) either suffer from limited performance, due to a two-stage setup, or require the designing of complex task-specific one-stage architectures. In this paper, we propose a simple one-stage multi-task framework for visual grounding tasks. Specifically, we leverage a transformer architecture, where two modalities are fused in a visual-lingual encoder. In the decoder, the model learns to generate contextualized lingual queries which are then decoded and used to directly regress the bounding box and produce a segmentation mask for the corresponding referred regions. With this simple but highly contextualized model, we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefits greatly from contextualized information and multi-task training.
+
+# 1 Introduction
+
+Multi-modal grounding1 tasks (e.g., phrase localization [1, 3, 9, 41, 48], referring expression comprehension [17, 19, 24, 26, 29, 30, 37, 51, 52, 55, 56] and segmentation [6, 18, 20, 21, 29, 38, 53, 56]) aim to generalize traditional object detection and segmentation to localization of regions (rectangular or at a pixel level) in images that correspond to free-form linguistic expressions. These tasks have emerged as core problems in vision and ML due to the breadth of applications that can make use of such techniques, spanning image captioning, visual question answering, visual reasoning and others.
+
+The majority of multi-modal grounding architectures, to date, take the form of two-stage approaches, inspired by Faster RCNN [44] and others, which first generate a set of image region proposals and then associate/ground one, or more, of these regions to a phrase by considering how well the content matches the query phrase. Context among the regions and multiple query phrases, which often come parsed from a single sentence, has also been considered in various ways (e.g., using LSTM stacks [9], graph neural networks [1] and others). More recent variants leverage pre-trained multi-modal Transformers (e.g., ViLBERT [33, 34]) to fine-tune to the grounding tasks. Such models have an added benefit of being able to learn sophisticated cross-modal feature representations from external large-scale data, which further improve the performance. However, a significant limitation of all such two-stage methods is their inability to condition the proposal mechanism on the query phrase itself, which inherently limits the upper bound of performance (see Table 3 in [51]).
+
+To address these limitations, more recently, a number of one-stage approaches have been introduced [22, 36, 51, 52]. Most of these take inspiration from Yolo [43] and the variants, and rely on more integrated visual-linguistic fusion and a dense anchoring mechanism to directly predict the grounding regions. While this alleviates the need for a proposal stage, it instead requires somewhat ad hoc anchor definitions, often obtained by clustering of labeled regions, and also limits ability to contextualize grounding decisions as each query phrase is effectively processed independently. Finally, little attention in the literature has been given to leveraging relationship among the REC and RES tasks.
+
+In this work we propose an end-to-end one-stage architecture, inspired by the recent DETR [2] detection framework, which is capable of simultaneous language grounding at both a boundingbox and segmentation level, without requiring dense anchor definitions. This model also enables contextualized reasoning by taking into account the entire image, all referring query phrases of interest and (optionally) lingual context (e.g., a sentence from which referring phrases are parsed). Specifically, we leverage a transfomer architecture, with a visual-lingual encoder, to encode image and lingual context, and a two-headed (detection and segmentation) custom contextualized tranformer decoder. The contextualized decoder takes as input learned contextualized phrase queries and decodes them directly to bounding boxes and segmentation masks. Implicit 1-to-1 correspondence between input referring phrases and resulting outputs also enables a more direct formulation of the loss without requiring Hungarian matching. With this simple model we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefit greatly from the contextualized information and the multi-task training.
+
+Contributions. Our contributions are: (1) We propose a simple and general one-stage transformerbased architecture for referring expression comprehension and segmentation. The core of this model is the novel transformer decoder that leverages contextualized phrase queries and is able to directly decode those, subject to contextualized image embeddings, into corresponding image regions and segments; (2) Our approach is unique in enabling simultaneous REC and RES using a single trained model (the only other method capable of this is [36]); showing that such multi-task learning leads to improvements on both tasks; (3) As with other transformer-based architectures, we show that pre-training can further improve the performance and both vanila and pre-trained models outperform state-of-the-art on both tasks by significant margins (up to $8 . 5 \%$ on RefCOCO dataset for REC and $1 9 . 4 \%$ for RES). We also thoroughly validate our design in detailed ablations.
+
+# 2 Related works
+
+Referring Expression Comprehension (REC). REC focuses on producing an image bounding box tightly encompassing a language query. Previous two-staged works [17, 19, 29, 30, 56] reformulate this as a ranking task with a set of candidate regions predicted from a pre-trained proposal mechanism. Despite achieving great success, the performance of two-staged methods is capped by the speed and accuracy of region proposals in the first stage. More recently, one-stage approaches [26, 51, 52] have been used to alleviate the aforementioned limitations. Yang et al. [51, 52] proposed to fuse query information with visual features and pick the bounding box with maximum activation scores from YOLOv3 [43]. Yang et al. [50] explore language structure guided propagation in the context of one stage grounding. Liao et al. [26] utilizes CenterNet [11] to perform correlation filtering for region center localization. However, such methods either require manually tuned anchor boxes or suffer from semantic loss due to modality misalignment. In contrast, our model learns to better align modalities using a cross-modal transformer and directly decode bounding boxes for each query.
+
+Referring Expression Segmentation (RES). Similar to REC, RES, proposed in [18], aims to predict segmentation masks to better describe the shape of the referred region. A typical solution for referring expression segmentation is to fuse multi-modal information with a segmentation network (e.g., [16, 31]) and train it to output the segmented masks [18, 29, 38, 53, 56]. More recent approaches focus on designing module to enable better multi-modal interactions, e.g., progressive multi-scale fusion used in [21] and cross-modal attention block used in [20]. Since localization information matters in predicting instance segmentations (as noted in Mask RCNN [16]), very recent work [22] aims to explicitly localize object before doing segmentation. Despite the relatively high performance being achieved in RES, existing approaches still struggle to determine the correct referent region and tend to output noisy segmentation results with an irregular shape, while our model is able to produce segmentations with fine-grained shapes even on challenging scenarios with occlusions or shadows.
+
+Multi-task Learning for REC and RES. Multi-task learning is widely applied in object detection and segmentation [2, 16], often, by leveraging shared backbone and task-specific heads. Building on this idea, Luo et al. [36] proposed a multi-task collaborative network (MCN) to jointly address REC and RES. They introduce consistency energy maximization loss that constrains the feature activation map in REC and RES to be similar. While our model is also set up to learn REC and RES tasks jointly, we argue that an explicit constraint tends to downplay the quality of the final predicted mask since the feature map from the REC branch can blur out fine-grained region shape information needed by the RES branch (see Figure 2). Hence, we use an implicit constraint where tasks head of REC and RES are trained to output corresponding bounding box and mask from the same joint multi-modal representation. We illustrate that our model can benefit from multi-task supervision, leading to more accurate results as compared to single-task variants.
+
+Pretrained Multi-modal Transformers. Transformer-based pretrained models [5, 12, 33, 47, 54] have recently showed strong potential in multi-modal understanding. LXMERT [47] and ViLBERT [33] use two stream transformers with cross-attention transformer layers on top for multimodal fusion. More recent works, [5, 12] advocate a single-stream design to fuse two modalities earlier. The success of the aforementioned models can largely be attributed to the cross-modal representations obtained by multi-task pretraining on a large amount of aligned image-text pairs. Despite state-of-the-art performance of such models on the downstream REC task, these models, fundamentally, are still a form of a two-stage pipeline where image features are extracted using pretrained detectors or proposal mechanisms. We focus on a one-stage architecture variant that allows visual and lingual features to be aligned at the early stages. Although the focus of our work is not to design a better pretraining scheme, we show that our model can outperform the existing state-of-the-art with proper pretraining.
+
+Transformer-based Detectors. More recently, DETR [2] and its variants [13, 58], were proposed to enable end-to-end object detection. DETR reformulates detection as a set prediction tasks and uses transformers to decode learnable queries to bounding boxes. Despite state-of-art performance, DETR is disadvantaged by its optimization difficulty and, usually, extra-long training time. While adopting a similar pipeline, our model focus on aligning different modalities to generate contextualized expression-specific referring queries. We also design our model to get rid of Hungarian matching loss by leveraging one-to-one correspondences between predicted bounding boxes and referring expressions, which leads to faster convergence for our model.
+
+# 3 Approach
+
+Given an image $\mathcal { T }$ and a set of query phrases $\mathcal { Q } _ { p } = \{ \mathbf { p } _ { i } \} _ { i = 1 , \dots , M }$ , that we assume to come from an (optional) contextual text source2 $\mathcal { Q }$ , our goal is to predict a set of bounding boxes $B = \{ \mathbf { b } _ { i } \} _ { i = 1 , \dots , M }$ and corresponding segmentation masks ${ \cal S } = \{ { \bf s } _ { i } \} _ { i = 1 , \dots , M }$ , one for each query phrase $i$ that localizes that phrase in the image. Note, $M$ is the number of phrases / referring expressions for a given image $\mathcal { T }$ and is typically between 1 and 16 for the Flick $3 0 \mathrm { k }$ [41] dataset.
+
+As shown in Figure 1, our referring transformer is composed of four components. Given an image(con)text pair, $<  { \mathcal { T } } ,  { \mathcal { Q } } >$ , a cross-modal encoder generates joint image-text embeddings for each visual and textual token – feature columns and word embeddings respectively. Query phrases $\mathcal { Q } _ { p }$ and image-text embeddings are then fed into a query encoder which produces query phrase embeddings. The decoder jointly reasons across all these query phrase embeddings and decodes multi-task feature, which is then sent to the detection and segmentation head to produce a set of boxes $\boldsymbol { B }$ and masks $s$ The result is a one-staged end-to-end model that solves the REC and RES tasks at the same time. We will now introduce constituent architectural components for the four stages briefly described above.
+
+# 3.1 Feature Extraction
+
+Visual & Text Backbone. Starting from an initial image $\mathcal { T } \in \mathbb { R } ^ { 3 \times H _ { 0 } \times W _ { 0 } }$ , we adopt the widely used ResNet [15] to generate its low-resolution feature map $\mathbf { f } _ { I } \in \mathbb { R } ^ { C _ { i } \times H W }$ . For the corresponding expression or sentence, we use the uncased base of BERT [8] to obtain the representation $\mathbf { f } _ { Q } \in$ $\mathbb { R } ^ { C _ { t } \times N }$ , while $N$ is the length of the input context sentence.
+
+![](images/e40ae0a0b3ed22270911f094dd1b90cc0e55acb591f3e2843ed7485181a3033e.jpg)  
+Figure 1: Referring Transformer. An overview of the proposed architecture is shown in (a). For an image and (con)text input, a visual-lingual encoder is used to refine image features, extracted from a convolutional backbone, and lingual features, extracted by a BERT. A query encoder and decoder produce features for REC and RES heads, given multi-modal features and query phrases. The detailed structure of the query encoder and decoder is shown in (b). Colored squares denote embeddings for corresponding query phrases.
+
+Visual-Lingual Encoder. The visual-lingual encoder is designed to fuse information from multimodal sources. For cross-modality encoding, we use a transformer encoder based model, which is composed of 6 transformer encoder layers. Specifically, given both image and text features, multi-layer perceptrons are applied first to project different modalities to a joint embedding space with a hidden dimension of $C$ . To provide transformer encoders with positional information, we follow [2, 8] to add cosine positional embedding $P _ { i m g }$ for image features and learnable positional embedding $P _ { t e x t }$ for text features. We then concatenate the projected features into a single sequence $\mathbf { f } ~ \in ~ \mathbb { R } ^ { C \times ( H W + N ) }$ . To distinguish between modalities, we also deign a learnable modal label embedding $E _ { l a b e l } : \{ E _ { i m g } , E _ { t e x t } ^ { - } \}$ which is added to the original sequences. The visual-lingual encoder then takes a sequence as input, and $\{ P _ { i m g } , P _ { t e x t } , E _ { l a b e l } \}$ are fed into each encoder layer. The encoder output is a multi-modal feature sequence $\mathbf { f } _ { v l } \in \mathbb { R } ^ { C \times ( H W + N ) }$ .
+
+# 3.2 Query Encoder and Decoder
+
+The query encoder and decoder aims to encode / decode query phrases, conditioned on visual-lingual features from the encoder, into an output bounding box and segmentation. In this stage, we first generate embeddings corresponding to each query phrase. These query phrase embeddings are then fed into the decoder together with the visual-lingual features from the encoder to generate outputs.
+
+Encoding Query Phrases. To enable the decoder to generate the desired output (bounding box and/or segmentation) the queries must encode several bits of crucial information. Mainly, (1) encoding of the query phrases, (2) image encoding and (3) phrase-specific optional (con)text information. For phrase encoding in (1) we use a BERT model with pooling heads which share weights with (con)text encoder; this results in the phrase feature vector $\mathbf { f _ { p } } _ { i } \in \mathbb { R } ^ { C }$ for the $i$ -th referring phrase. We note that because we use visual-lingual encoder, (2) and (3) are jointly encoded in multi-modal features $\mathbf { f } _ { v l }$ described in Section 3.1 above. However, $\mathbf { f } _ { v l }$ is phrase-agnostic encoding of the image and (con)text. To generate phrase-specific context, given a phrase $\mathbf { p } _ { i }$ , average pooling is used to extract the phrase-specific context information $\mathbf { f } _ { c } ( \mathbf { p } _ { i } )$ from the visual-lingual feature sequence as follows:
+
+$$
+\mathbf { f } _ { c } ( \mathbf { p } _ { i } ) = \frac { \sum \mathbf { f } _ { v l } [ l _ { \mathbf { p } _ { i } } : r _ { \mathbf { p } _ { i } } ] } { r _ { \mathbf { p } _ { i } } - l _ { \mathbf { p } _ { i } } }
+$$
+
+where $l _ { \mathbf { p } _ { i } }$ and $r _ { \mathbf { p } _ { i } }$ denotes the left and right bounds of phrase $\mathbf { p } _ { i }$ in the original (con)text sentence. Finally, given phrase encoding $\mathbf { f _ { p } } _ { i }$ and phrase-specific context $\mathbf { f } _ { c } ( \mathbf { p } _ { i } )$ we construct our phrase queries
+
+using a multi-later perceptron:
+
+$$
+\widehat { Q _ { { \bf p } i } } = \mathtt { M L P } \left( [ { \bf f } _ { c } ( { \bf p } _ { i } ) ; { \bf f _ { p } } _ { i } ] \right) + E _ { p } ,
+$$
+
+where $E _ { p } \in \mathbb { R } ^ { C }$ is a learnable embedding which serves as a bias to the formed query.
+
+Decoding. In the decoder, self attention layers are used to enable information flow in a dense connected graph of phrase queries. This allows phrase queries to contextualize and refine each other; the inspiration for this step is taken from [1]. After that, a cross attention layer decodes visual-lingual information given the updated phrase query and feature sequence from the encoder. The design of our decoder is similar to the transformer decoder, except attention is non-causal.
+
+# 3.3 Multi-task training
+
+In this section, we demonstrate how the decoded phrase-specific query features can be naturally used to train multiple heads for different referring tasks (regression for REC and segmentation for RES).
+
+Referring Comprehension/Detection (REC). For referring detection tasks, the final output is computed by a simple two-layer perceptron over the decoded phrase-specific query features. We let the detection head directly output center coordinates $\tilde { \mathbf { b } } = ( x , y , h , w )$ for the referred image. To supervise the training, we use a weighted sum of an L1 loss and a Generalized IOU loss [45]:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { d e t } = \lambda _ { i o u } \mathcal { L } _ { i o u } ( \mathbf { b } , \tilde { \mathbf { b } } ) + \lambda _ { L 1 } | | \mathbf { b } - \tilde { \mathbf { b } } | | _ { 1 } . } \end{array}
+$$
+
+The $\lambda _ { i o u }$ and $\lambda _ { L 1 }$ control the relative weighting of the two losses in the REC objective.
+
+Referring Segmentation (RES). Following previous work [2], we design an FPN-like architecture to predict a referring segmentation mask for each phrase expression. Attention masks from the decoder and image features from the visual-lingual encoder are concatenated as the FPN input, while features from different stages of image backbones are used as skip connections to refine the final output. The last linear layer project the upsampled feature to a single channel heatmap and a sigmoid function is used to map the feature to mask scores $\tilde { \mathbf { s } } \in \mathbb { R } ^ { H _ { 0 } / 4 \times W _ { 0 } / 4 }$ . The loss for training RES task is:
+
+$$
+\begin{array} { r } { \mathcal { L } _ { s e g } = \lambda _ { f o c a l } \mathcal { L } _ { f o c a l } ( \mathbf { s } , \tilde { \mathbf { s } } ) + \lambda _ { d i c e } \mathcal { L } _ { d i c e } ( \mathbf { s } , \tilde { \mathbf { s } } ) . } \end{array}
+$$
+
+Here $\mathcal { L } _ { f o c a l }$ is the focal loss for classifying pixels used in [28], $\mathcal { L } _ { d i c e }$ is the DICE/F-1 loss proposed in [39]; $\lambda _ { f o c a l }$ and $\lambda _ { d i c e }$ are hyper-parameters controlling the relative importance of the two losses.
+
+Joint Training. While it is possible to train referring segmentation and referring detection tasks separately, we find that joint training is highly beneficial. Therefore the combined training loss which we optimize is $\mathcal { L } = \mathcal { L } _ { s e g } + \mathcal { L } _ { d e t }$ .
+
+Pretraining the Transformer. Transformers are generally data hungry and requires a lot of data to train [5, 33]. Although in this paper we do not use a large pretraining model and a lot of data. We found that simple pretraining strategy on the region description splits of Visual-Genome dataset [25] makes our model achieve comparable and even better performance against some of state-of-the-art pretrained models. Interestingly, we found that although there is no ground truth segmentation provided in Visual-Genome, the RES task can still benefit greatly from pretrained models, likely due to the fine-tuned multi-task representation.
+
+# 4 Experiments
+
+# 4.1 Datasets
+
+RefCOCO/RefCOCO $^ +$ /RefCOCOg (REC&RES). RefCOCO, RefCOCO $^ +$ [55] and RefCOCOg [40] are collections of images and referred objects from MSCOCO [27]. On RefCOCO and Ref$\mathrm { C O C O + }$ we follow the split used in [55] and report scores on the validation, testA and testB splits. On RefCOCOg, we use the RefCOCO-umd splits proposed in [40].
+
+Flickr30k Entities (REC). Flickr30k Entities [41] contains 31,783 images and $1 5 8 \mathrm { k }$ caption sentences with 427k annotated phrase. We use splits from [41, 42]. Bounding boxes and phrase annotations are consistent with the previous one-stage approaches [51, 52] for fair comparisons.
+
+ReferIt (REC). The ReferItGame dataset [24] contains 20,000 images. We follow setup in [3] for splitting train, validation and test set; resulting in 54k, 6k and 6k referring expressions respectively.
+
+Table 1: Comparison on REC task. Performance on RefCOCO/RefCOCO+/RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 and RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone.   
+
+<table><tr><td rowspan="2">Models</td><td rowspan="2">Visual Features</td><td rowspan="2">Pretrain Images</td><td rowspan="2">Multi- task</td><td colspan="3">RefCOCO</td><td colspan="3">RefCOCO+</td><td rowspan="2">RefCOCOg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB val-u</td></tr><tr><td>Two-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>CMN[19]</td><td>VGG16</td><td>None</td><td>×</td><td>-</td><td>71.03</td><td>65.77</td><td>-</td><td>54.32</td><td>47.76</td><td>-</td><td>-</td></tr><tr><td>RvG-Tree [17]</td><td>RN101</td><td>None</td><td>×</td><td>75.06</td><td>78.61</td><td>69.85</td><td>63.51</td><td>67.45</td><td>56.66</td><td>66.95</td><td>66.51</td></tr><tr><td>CM-Att-Erase [30]</td><td>RN101</td><td>None</td><td>×</td><td>78.35</td><td>83.14</td><td>71.32</td><td>68.09</td><td>73.65</td><td>58.03</td><td>67.99</td><td>68.67</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>None</td><td>√</td><td>76.65</td><td>81.14</td><td>69.99</td><td>65.33</td><td>71.62</td><td>56.02</td><td>66.58</td><td>67.27</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>None</td><td>√</td><td>76.41</td><td>81.21</td><td>70.09</td><td>66.46</td><td>72.02</td><td>57.52</td><td>65.87</td><td>66.44</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>None</td><td>×</td><td>-</td><td>81.06</td><td>71.85</td><td>-</td><td>70.35</td><td>56.32</td><td>-</td><td>65.73</td></tr><tr><td>SSG [4]</td><td>DN53</td><td>None</td><td>×</td><td>=</td><td>76.51</td><td>67.50</td><td>-</td><td>62.14</td><td>49.27</td><td>58.80</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>None</td><td>×</td><td>72.54</td><td>74.35</td><td>68.50</td><td>56.81</td><td>60.23</td><td>49.60</td><td>61.33</td><td>60.36</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>None</td><td>×</td><td>77.63</td><td>80.45</td><td>72.30</td><td>63.59</td><td>68.36</td><td>56.81</td><td>67.30</td><td>67.20</td></tr><tr><td>MCN[36]</td><td>DN53</td><td>None</td><td>√</td><td>80.08</td><td>82.29</td><td>74.98</td><td>67.16</td><td>72.86</td><td>57.31</td><td>66.46</td><td>66.01</td></tr><tr><td>Ours</td><td>RN50</td><td>None</td><td>√</td><td>81.82</td><td>85.33</td><td>76.31</td><td>71.13</td><td>75.58</td><td>61.91</td><td>69.32</td><td>69.10</td></tr><tr><td>Ours</td><td>RN101</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VilBERT[33]</td><td>RN101</td><td>3.3M</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>RN101</td><td></td><td>×</td><td>-</td><td>=</td><td>-</td><td>72.34</td><td>78.52</td><td>62.61</td><td>1</td><td>-</td></tr><tr><td>ERNIE-ViL_L[54]</td><td>RN101</td><td>4.3M 4.6M</td><td>×</td><td>=</td><td></td><td></td><td>75.89</td><td>82.37</td><td>66.91</td><td></td><td></td></tr><tr><td>UNTIER_L[5]</td><td>RN101</td><td>4.6M</td><td>×</td><td>81.41</td><td>87.04</td><td>74.17</td><td>75.90</td><td>81.45</td><td>66.70</td><td>74.86</td><td>75.77</td></tr><tr><td>VILLA_L[12]</td><td>RN50</td><td></td><td>×</td><td>82.39</td><td>87.48</td><td>74.84</td><td>76.17</td><td>81.54</td><td>66.84</td><td>76.18</td><td>76.71</td></tr><tr><td>Ours*</td><td></td><td>100k</td><td>√</td><td>85.43</td><td>87.48</td><td>79.86</td><td>76.40</td><td>81.35</td><td>66.59</td><td>78.43</td><td>77.86</td></tr><tr><td>Ours*</td><td>RN101</td><td>100k</td><td>√</td><td>85.65</td><td>88.73</td><td>81.16</td><td>77.55</td><td>82.26</td><td>68.99</td><td>79.25</td><td>80.01</td></tr></table>
+
+# 4.2 Implementing Details
+
+We train our model with AdamW [32]. The initial learning rate is set to 1e-4 while the learning rate of image backbone and context encoder is set to 1e-5. We initialized weights in the transformer encoder and decoder with Xavier initialization [14]. For image backbone, we experiment with the popular ResNet-50 and ResNet-101 networks [15] where weights are initialized from corresponding ImageNet-pretrained models. For the context encoder and phrase encoder, we use an uncased version of BERT model [8] with weights initialized from pretrained checkpoints provided by HuggingFace [49]. For data augmentation, we scale images such that the longest side is 640 pixels and follow [51] to do random intensity saturation and affine transforms. We remove the random horizontal flip augmentation used in previous work [51] since we notice it causes semantic ambiguity on RefCOCO, likely due to relative location (e.g., left of/right of) specific queries in the dataset.
+
+On Flickr30k dataset, we set the maxium length of context sentence to 90 and maximum number of referring phrases to 16. On the ReferIt and the RefCOCO dataset, only phrase expressions are provided and the task aims to predict a single bounding box for each of the expressions. In those cases, the context sentence is taken as the referring phrase expression itself. We set the maximum length of context sentence on these two datasets to 40. To fairly compare with pretrained methods, we use region description split in the VisualGenome [25] to pretrain our model. The dataset contains approximately $1 0 0 \mathrm { k }$ images and we remove the images that appear in Flickr30k Entities and RefCOCO/RefCOCOg/RefCOCO+’s validation and test set to avoid potential test data leak. For all the pretrained methods, we train the model on pretraining dataset for 6 epoches. We find that longer pretraining schedule gives better performance, but since the focus of this paper is not on pretraining methods, we stick to shorter pretraining schedules to save computational resources. All experiments are conducted using 4 Nvidia 2080TI GPU with batch size as 32. For all the results given, we run experiments several times with random seeds and the error bars are within $\pm 0 . 5 \%$ .
+
+# 4.3 Quantitative Analysis
+
+Evaluation Metrics. For referring expression comprehension (REC), consistent with prior works, we use precision as the evaluation metric. We mark a referring detection as correct when the intersection-over-union (IoU) between the predicted bounding box and ground truth is larger than 0.5. For referring expression segmentation (RES), we reported the Mean IoU (MIoU) between the predicted segmentation mask and ground truth mask.
+
+REC and RES on RefCOCO/RefCOCO $+$ /RefCOCOg. Our model addresses REC and RES tasks jointly. We compare their respective performances with the state-of-the-art in Table 1 and 2.
+
+Table 2: Comparison on RES tasks. Performance on RefCOCO/RefCOCO $+$ /RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 abd RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone.   
+
+<table><tr><td rowspan="2">Methods</td><td rowspan="2">Backbone</td><td colspan="3">RefCOCO</td><td colspan="3">RefCOCO+</td><td colspan="2">RefCOCOg</td><td rowspan="2">Inference time(ms)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td><td>val</td><td>test</td></tr><tr><td>DMN [38]</td><td>RN101</td><td>49.78</td><td>54.83</td><td>45.13</td><td>38.88</td><td>44.22</td><td>32.29</td><td>-</td><td>-</td><td>-</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>56.51</td><td>62.37</td><td>51.70</td><td>46.67</td><td>52.39</td><td>40.08</td><td>47.64</td><td>48.61</td><td>378</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>56.59</td><td>63.02</td><td>52.06</td><td>47.40</td><td>53.01</td><td>41.56</td><td>46.59</td><td>47.88</td><td>1</td></tr><tr><td>Lang2seg [6]</td><td>RN101</td><td>58.90</td><td>61.77</td><td>53.81</td><td>-</td><td>-</td><td>-</td><td>46.37</td><td>46.95</td><td></td></tr><tr><td>BCAM[20]</td><td>RN101</td><td>61.35</td><td>63.37</td><td>59.57</td><td>48.57</td><td>52.87</td><td>42.13</td><td>-</td><td>=</td><td></td></tr><tr><td>CMPC[21]</td><td>RN101</td><td>61.36</td><td>64.53</td><td>59.64</td><td>49.56</td><td>53.44</td><td>43.23</td><td>=</td><td>=</td><td>=</td></tr><tr><td>MCN+ASNLS [36]</td><td>DN53</td><td>62.44</td><td>64.20</td><td>59.71</td><td>50.62</td><td>54.99</td><td>44.69</td><td>49.22</td><td>49.40</td><td>56</td></tr><tr><td>CGAN [35]</td><td>DN53</td><td>64.86</td><td>68.04</td><td>62.07</td><td>51.03</td><td>55.51</td><td>44.06</td><td>51.01</td><td>51.69</td><td>-</td></tr><tr><td>LTS [22]</td><td>DN53</td><td>65.43</td><td>67.76</td><td>63.08</td><td>54.21</td><td>58.32</td><td>48.02</td><td>54.40</td><td>54.25</td><td>1</td></tr><tr><td>Ours</td><td>RN50</td><td>69.94</td><td>72.80</td><td>66.13</td><td>60.9</td><td>65.20</td><td>53.45</td><td>57.69</td><td>58.37</td><td>38</td></tr><tr><td>Ours</td><td>RN101</td><td>70.56</td><td>73.49</td><td>66.57</td><td>61.08</td><td>64.69</td><td>52.73</td><td>58.73</td><td>58.51</td><td>41</td></tr><tr><td>Ours*</td><td>RN50</td><td>73.61</td><td>75.22</td><td>69.80</td><td>65.30</td><td>69.69</td><td>56.98</td><td>65.70</td><td>65.41</td><td>38</td></tr><tr><td>Ours*</td><td>RN101</td><td>74.34</td><td>76.77</td><td>70.87</td><td>66.75</td><td>70.58</td><td>59.40</td><td>66.63</td><td>67.39</td><td>41</td></tr></table>
+
+![](images/ae52ea765ab73627d130406f12ccbc83f1847c53fe2d5875520aa3f4dee6d22d.jpg)  
+Figure 2: Qualitative Evaluation. In (a) comparison to MCN [36] on REC is shown; orange, blue and red bounding boxes correspond to outputs from MCN, our model and the ground truth. In (b) similar comparison on RES is made. The attention map is drawn from the last layer of the decoder. We add mosaic to all human face to protect personal information.
+
+In Table 1, the model is first compared with previous one-stage and two-stage approaches for REC. Without bells and whistles, we observe a consistent performance boost of $+ 2 . 7 \% / + 4 \% / + 2 . 1 \%$ on RefCOCO, $+ 6 . 6 \% / + 4 . 3 \% / + 8 . 5 \%$ on $\operatorname { R e f C O C O + }$ and $+ 4 . 4 \% / + 5 . 1 \%$ on RefCOCOg. To compare with pretrained BERT methods, we use the pretraining strategy discussed in Section 3.3. As results show, our model achieves comprehensive advantage and shows distinct improvement on some splits, even compared to advance BERT models that use $4 0 \times$ more data in pretraining. Table 2 illustrates results on RES task in terms of MIoU score. It can be seen that our model achieves the best performance; substantially better than the state-of-art. We further observe that pretraining on the REC task gives a huge performance boost to the RES task, even when no segmentation mask is used in pre-training. Multi-task training enables the model to leverage performance boost in one task to improve the other.
+
+We show the inference time for our model in Table 2. Our model can directly decode all query phrases in an image in parallel, allowing it to reach real-time performance. Importantly, note the corresponding scores for our model in Table 1 and Table 2 are based on the output of a single multitask model that predicts referring detection box and segmentation mask simultaneously. The only related work that shares this property is the MCN [36], which has substantially inferior performance.
+
+Table 3: Comparison with State-of-The-Art Methods. Table illustrates performance on the test set of ReferItGame [24] and Flickr30K Entities [41] datasets in terms of top-1 accuracy $( \% )$ .   
+
+<table><tr><td>Models</td><td>Backbone</td><td>ReferItGame test</td><td>Flickr30K test</td><td>Inference time on Flickr30k(ms)</td></tr><tr><td colspan="5">Two-stage</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>29.04</td><td>-</td><td>320</td></tr><tr><td>Similarity Net [48]</td><td>RN101</td><td>34.54</td><td>60.89</td><td>184</td></tr><tr><td>CITE [42]</td><td>RN101</td><td>35.07</td><td>61.33</td><td>196</td></tr><tr><td>DDPN[57]</td><td>RN101</td><td>63.00</td><td>73.30</td><td>-</td></tr><tr><td colspan="5">One-stage</td></tr><tr><td>SSG[4]</td><td>DN53</td><td>54.24</td><td>-</td><td>25</td></tr><tr><td>ZSGNet [46]</td><td>RN50</td><td>58.63</td><td>58.63</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>60.67</td><td>68.71</td><td>23</td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>63.79</td><td>-</td><td>25</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>64.60</td><td>69.28</td><td>36</td></tr><tr><td>Ours</td><td>RN50</td><td>70.81</td><td>78.13</td><td>37(14)</td></tr><tr><td>Ours</td><td>RN101</td><td>71.42</td><td>78.66</td><td>40(15)</td></tr><tr><td>Ours*</td><td>RN50</td><td>75.49</td><td>79.46</td><td>37(14)</td></tr><tr><td>Ours*</td><td>RN101</td><td>76.18</td><td>81.18</td><td>40(15)</td></tr></table>
+
+REC on Flickr30k-Entities. For Flickr30k dataset, previous one-stage works [51, 52] extract short phrases from sentences and treated them as separate referring expression comprehension tasks. We argue that in this setting, queries are mostly short phrases and therefore cannot well reflect the model’s ability to comprehend them in context. In contrast, our model, given an image and a caption (con)text sentence, aims to predict bounding boxes for all referred entities in the sentence. Doing so gives several advantages: 1. We are able to contextualize referring expressions given all other referring expressions and (con)text provided by the sentence. 2. Locations for all phrases can be inferred in one forward pass of the network, which saves a lot of computation as compared to previous one-stage approaches [51, 52] that process one phrase at a time. Note that our task formulation is consistent with some two-stage models [1, 9], but is unique for a one stage approach.
+
+In Table 3 we compare our results with state-of-the-art methods. Without pretraining, we obtain a huge performance boost compared to both previous one-stage $( + 1 3 . 5 4 \% )$ and two-stage $( + 7 . 3 1 \% )$ state-of-the art methods. By using pretrained models, we observe that our model tends to generalize better on the test set and gives even better performance. We also provide comparison of inference time both per image and (per-expression), since our model can amortize inference across expressions. Per-expression, our inference time is substantially lower than all prior methods.
+
+REC on ReferIt. Since ReferIt is a relative small dataset, we use a slightly smaller model which contains 3 cross attention layers in the query decoder. The results are shown in Table 3. Our model is able to perform better, by a large margin, than even the latest one-stage methods. We also observe a consistent boost brought by pretraining.
+
+# 4.4 Qualitative Analysis
+
+In Figure 2, we show our qualitative comparison with previous state-of-the-art multi-task model – MCN [36]. The first two rows of Figure 2(a) show failure cases of MCN that can be better handled by our model. We observe that MCN appears to fail because it neglects some attributes in referring expression (e.g., "yellow drink" and "blue striped shirt"), while our model is able to better model the query and pay attention to object attributes. In the last row, we shows several failure cases of our model. For the first case, the query requires the model to have the ability to recognize number $" 4 4 "$ . For the second and third case, there is visual ambiguity to identify the nearest glass to the bowl or to determine which bear(brown or white) has the longest leg.
+
+In Figure 2(b), we show qualitative comparison in terms of referred segmentation mask. Compared to MCN, our model is able to output more detailed object shape and finer outlines. Moreover, our model shows the ability to handle shadows (e.g., the right bottom of the donut) and occlusions (e.g., the man occluded by another man’s arm) and predict smoother segmentation mask. We also give a result on a challenging case in the last row, where the texture boundary of the two giraffe is hard to distinguish. Despite imperfections, our model is still able to focus on the giraffe’s head in the foreground and performs much better than MCN. Part of our model’s ability to generate fine-grained mask can be explained by better localization ability brought by the REC task, in which case the RES head can focus on tuning the shape and boundary of the mask.
+
+Table 4: Ablation studies. Table on the top ablates our multi-task and pretraining schehme on $\operatorname { R e f C O C O } / + / \mathrm { g }$ validation set. Table on the bottom ablates on core components of our model.   
+
+<table><tr><td>REC</td><td>RES Pretrain</td><td>REC Acc↑</td><td>RESMiou↑</td><td>IE</td></tr><tr><td>√</td><td>√</td><td>81.08 /70.02/68.15</td><td>66.03/58.39/54.61 =</td><td>23.52%</td></tr><tr><td>√</td><td>√</td><td>81.82 / 71.13 /69.32</td><td>69.94 / 60.90 / 57.69</td><td>4.73%</td></tr><tr><td>√</td><td>√</td><td>85.01/75.46/77.96</td><td>=</td><td></td></tr><tr><td>√</td><td>√ √</td><td>85.43 / 76.40 / 78.43</td><td>73.61 / 65.30 / 65.70</td><td>4.48%</td></tr></table>
+
+Table 5: Results on RefCOCO $^ +$ Dataset with Different Input Resolutions. Our methods correspond to the RN50 model without pretraining.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Flickr30k</td></tr><tr><td rowspan=1 colspan=1>Model component-w/o Query Decoder-w/o Context Encoder</td><td rowspan=1 colspan=1>49.3873.68</td></tr><tr><td rowspan=1 colspan=1>Query Encoder-w/o Context&amp;Phrase Feature-w/o Context Feature-w/o Phrase Feature</td><td rowspan=1 colspan=1>42.0576.6477.02</td></tr><tr><td rowspan=1 colspan=1>Full model</td><td rowspan=1 colspan=1>78.13</td></tr></table>
+
+<table><tr><td rowspan="2">Models</td><td rowspan="2">Resolution</td><td colspan="3">REC(prec@0.5)</td><td colspan="3">RES(MIoU)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td></tr><tr><td>FAOA [51]</td><td>256× 256</td><td>56.81</td><td>60.23</td><td>49.60</td><td>-</td><td>-</td><td>-</td></tr><tr><td>ReSC-Large [52]</td><td>256× 256</td><td>63.59</td><td>68.36</td><td>56.81</td><td>-</td><td>-</td><td>1</td></tr><tr><td>CMPC[21]</td><td>320×320</td><td>1</td><td>-</td><td>1</td><td>49.56</td><td>53.44</td><td>43.23</td></tr><tr><td>LTS [22]</td><td>416× 416</td><td>-</td><td>=</td><td>=</td><td>54.21</td><td>58.32</td><td>48.02</td></tr><tr><td>MCN [36]</td><td>416× 416</td><td>67.16</td><td>72.86</td><td>57.31</td><td>50.62</td><td>54.99</td><td>44.69</td></tr><tr><td>Ours</td><td>256× 256</td><td>70.05</td><td>73.29</td><td>61.48</td><td>58.26</td><td>61.09</td><td>52.20</td></tr><tr><td>Ours</td><td>320×320</td><td>70.03</td><td>73.23</td><td>61.52</td><td>58.42</td><td>61.48</td><td>52.34</td></tr><tr><td>Ours</td><td>416× 416</td><td>71.50</td><td>75.87</td><td>61.71</td><td>61.00</td><td>64.48</td><td>52.44</td></tr><tr><td>Ours</td><td>640× 640</td><td>71.58</td><td>75.96</td><td>62.16</td><td>61.08</td><td>64.69</td><td>52.73</td></tr></table>
+
+# 4.5 Ablation Studies
+
+We first consider the importance of the multi-task setup in Table 4 (top). Results indicate that multi-task training consistently boosts both REC and RES performance on Refcoco $/ + / \mathrm { g }$ datasets by a considerable margin. More specifically, we observe that REC loss helps the transformer to better locate the referred object and converge faster in early stages of training. At the same time, RES loss aids the model with more fine-grained information on the shape of the referred region, which helps to further enhance the accuracy. IE here is Inconsistency Error metric originally used in [36] to measure the prediction conflict between the REC and RES task. We can see that joint training of RES and REC greatly reduce the inconsistency between the two tasks. Note that our model also has a much lower multi-task inconsistency compared to MCN [36], with a corresponding IE score of $7 . 5 4 \% ( - 4 0 \% )$ . This shows that our model can do better collaborative learning.
+
+Next, we validate the design of our network architecture. We report our scores on the Flickr30k test sets. In Table 4 (bottom), we ablate the model’s major components and features used to form the query. Without (w/o) context encoder indicates that we directly use learnable embedding to encode text; w/o Query Decoder means that we directly use the average pooled feature from the encoder to predict a single referred output. We can see that the context encoder plays an important role in providing good textual representation for further multi-modal fusion. Query encoders are also quite important without which we also observe a big performance drop. For the ablation on query features, we observe that both context feature and phrase features are crucial without which the performance will decrease considerably. The table also showed that the network will not work without guidance of both context and phrase features since we cannot establish a correspondence between multiple queries and outputs in such a case.
+
+In RES and REC tasks, the size of input image is a matter of trade off between performance and speed, which is largely effected by the network architecture. Despite that our model is designed to be able to process $6 4 0 \times 6 4 0$ images at real time speed, we also test our model at different input resolution for reference, as showed in Table 5. Note that for resolution 256 and 320, we adjust strides in the final stage of ResNet to keep the number of visual features sent into visual-lingual encoder roughly the same.
+
+Table 6: Comparison with Concurrent Work. Performance on RefCOCO/RefCOCO $\left| + \right.$ /RefCOCOg datasets [55]. Ours∗ denotes that pretraining is used. All methods use ResNet101 image backbone.   
+
+<table><tr><td rowspan="2">Models</td><td rowspan="2">Visual Features</td><td rowspan="2">Pretrain Images</td><td rowspan="2">Multi- task</td><td colspan="3">RefCOCO</td><td colspan="3">RefCOCO+</td><td rowspan="2">RefC0COg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>testA</td><td>testB</td><td>val-u</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td>val</td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>VGTR [10]</td><td>Bi-LSTM</td><td>None</td><td>×</td><td>79.20</td><td>82.32</td><td>73.78</td><td>63.91</td><td>70.09</td><td>56.51</td><td>65.73</td><td>67.23</td></tr><tr><td>TransVG [7]</td><td>BERT</td><td>None</td><td>×</td><td>81.02</td><td>82.72</td><td>78.35</td><td>64.82</td><td>70.70</td><td>56.94</td><td>68.67</td><td>67.73</td></tr><tr><td>Ours</td><td>BERT</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td>√</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MDETR [23] Ours*</td><td>RoBERTa BERT</td><td>200k 100k</td><td>√</td><td>86.75 85.65</td><td>89.58 88.73</td><td>81.41 81.16</td><td>79.52 77.55</td><td>84.09 82.26</td><td>70.62 68.99</td><td>81.64 79.25</td><td>80.89 80.01</td></tr></table>
+
+# 4.6 Comparison with Contemporaneous Work
+
+Concurrent and independent to us, very recently, there are some closely related works that use transformers for visual referring tasks [7, 10, 23]. We will briefly discuss some of the differences.
+
+To begin, [7, 10] focus on REC, while our approach is formulated in multi-task setting and solves both REC and RES tasks simultaneously. In addition, our model is faster and is capable of grounding multiple contextualized phrases, while [7, 10] follow previous one-stage approaches and are only able to infer a single expression at a time; leading, in our case, to more accurate results. MDETR [23] leverages contrastive loss and soft token loss to help better match bounding boxes to phrases. In contrast, our method adopts a simple and straightforward method to pre-match bounding boxes to phrases using a one-to-one matching; this leads to simpler learning objective.
+
+We provide quantitative comparison on REC task with these approaches, based on their reported numbers in Table 6. Compared to [7, 10], our model performs substantially better in all, with an exception of RefCOCO testB (where [7] is marginally better), datasets and splits. The biggest improvements can be seen on $\operatorname { R e f C O C O + }$ , where our model is $1 0 . 4 \%$ better (or 6.76 points better), than the closest concurrent work of [7], on the Val split; similar sizable improvements are illustrated on other splits, e.g., $9 . 2 \%$ on $\operatorname { R e f C O C O + }$ testB. In addition, our approach is considerably faster in runtime, since our model is able to handle multiple queries simultaneously (unlike [7, 10]). Compared to [23], in a pretrained model setting, we see that our model performs similarly on RefCOCO and marginally worse on $\operatorname { R e f C O C O + }$ and $\operatorname { R e f C O C O g }$ . This difference can perhaps be attributed to two factors: (1) larger pretrain dataset and longer triaining schedule. (As reported in [23], MDETR takes 224 GPU days to pretrain, while the pretraining for our model is roughly 28 GPU days) (2) using more sophisticated language model (RoBERTa for [23] vs. BERT for us). Limited experiments in Supplemental Material show that indeed, the use of RoBERTa leads to certain improvements. In addition, we setup our method in multi-task setting to solve RES and REC task at the same time, so our formulation while perhaps marginally inferior on REC is more general overall.
+
+# 5 Conclusions and Future Work
+
+In this work, we present Referring Transformer, a one-step approach to referring expression comprehension (REC) and segmentation (RES). We jointly train our model for RES and REC tasks while enabling contextualized multi-expression references. Our models outperform state-of-the-art by a large margin on five / three datasets for REC / RES respectively, while achieving real-time runtime.
+
+One limitation for our model is that we follow the setup in previous works [51, 52] and assume that each expression refers to only one region. In the future, we plan to explore learning to predict multiple regions for each referring entity if necessary. Large-scale multi-task pretraining has been demonstrated to be very effective for ViLBEERT and other similar architectures; this is complementary to our focus in this paper, and we expect such strategies to further improve the performance.
+
+# 6 Acknowledgments and Disclosure of Funding
+
+This work was funded, in part, by the Vector Institute for AI, Canada CIFAR AI Chair, NSERC CRC, NSERC Discovery and Discovery Accelerator Grants. Resources used in preparing this research were provided, in part, by the Province of Ontario, the Government of Canada through CIFAR, and companies sponsoring the Vector Institute www.vectorinstitute.ai/#partners. Additional hardware support was provided by John R. Evans Leaders Fund CFI grant and Compute Canada under the Resource Allocation Competition award.
+
+References   
+[1] M. Bajaj, L. Wang, and L. Sigal. G3raphground: Graph-based language grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4281–4290, 2019.   
+[2] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision (ECCV), pages 213–229, 2020.   
+[3] K. Chen, R. Kovvuri, and R. Nevatia. Query-guided regression network with context policy for phrase grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 824–832, 2017.   
+[4] X. Chen, L. Ma, J. Chen, Z. Jie, W. Liu, and J. Luo. Real-time referring expression comprehension by single-stage grounding network. arXiv preprint arXiv:1812.03426, 2018.   
+[5] Y.-C. Chen, L. Li, L. Yu, A. El Kholy, F. Ahmed, Z. Gan, Y. Cheng, and J. Liu. Uniter: Universal image-text representation learning. In European Conference on Computer Vision (ECCV), pages 104–120, 2020.   
+[6] Y. W. Chen, Y. H. Tsai, T. Wang, Y. Y. Lin, and M. H. Yang. Referring expression object segmentation with caption-aware consistency. In Proceedings of the British Machine Vision Conference (BMVC), 2019.   
+[7] J. Deng, Z. Yang, T. Chen, W. Zhou, and H. Li. TransVG: End-to-end visual grounding with transformers. arXiv preprint arXiv:2104.08541, 2021.   
+[8] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, 2019.   
+[9] P. Dogan, L. Sigal, and M. Gross. Neural sequential phrase grounding (seqground). In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 4175–4184, 2019.   
+[10] Y. Du, Z. Fu, Q. Liu, and Y. Wang. Visual grounding with transformers. arXiv preprint arXiv:2105.04281, 2021.   
+[11] K. Duan, S. Bai, L. Xie, H. Qi, Q. Huang, and Q. Tian. Centernet: Keypoint triplets for object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 6569–6578, 2019.   
+[12] Z. Gan, Y.-C. Chen, L. Li, C. Zhu, Y. Cheng, and J. Liu. Large-scale adversarial training for vision-andlanguage representation learning. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), 2020.   
+[13] P. Gao, M. Zheng, X. Wang, J. Dai, and H. Li. Fast convergence of detr with spatially modulated co-attention. arXiv preprint arXiv:2101.07448, 2021.   
+[14] X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pages 249–256, 2010.   
+[15] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016.   
+[16] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask r-cnn. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2961–2969, 2017.   
+[17] R. Hong, D. Liu, X. Mo, X. He, and H. Zhang. Learning to compose and reason with language tree structures for visual grounding. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2019.   
+[18] R. Hu, M. Rohrbach, and T. Darrell. Segmentation from natural language expressions. In European Conference on Computer Vision (ECCV), pages 108–124, 2016.   
+[19] R. Hu, M. Rohrbach, J. Andreas, T. Darrell, and K. Saenko. Modeling relationships in referential expressions with compositional modular networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1115–1124, 2017.   
+[20] Z. Hu, G. Feng, J. Sun, L. Zhang, and H. Lu. Bi-directional relationship inferring network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[21] S. Huang, T. Hui, S. Liu, G. Li, Y. Wei, J. Han, L. Liu, and B. Li. Referring image segmentation via cross-modal progressive comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[22] Y. Jing, T. Kong, W. Wang, L. Wang, L. Li, and T. Tan. Locate then segment: A strong pipeline for referring image segmentation. arXiv preprint arXiv:2103.16284, 2021.   
+[23] A. Kamath, M. Singh, Y. LeCun, I. Misra, G. Synnaeve, and N. Carion. MDETR–modulated detection for end-to-end multi-modal understanding. arXiv preprint arXiv:2104.12763, 2021.   
+[24] S. Kazemzadeh, V. Ordonez, M. Matten, and T. Berg. Referitgame: Referring to objects in photographs of natural scenes. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 787–798, 2014.   
+[25] R. Krishna, Y. Zhu, O. Groth, J. Johnson, K. Hata, J. Kravitz, S. Chen, Y. Kalantidis, L.-J. Li, D. A. Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. International Journal of Computer Vision (IJCV), 123(1):32–73, 2017.   
+[26] Y. Liao, S. Liu, G. Li, F. Wang, Y. Chen, C. Qian, and B. Li. A real-time cross-modality correlation filtering method for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   
+[27] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft coco: Common objects in context. In European Conference on Computer Vision (ECCV), pages 740–755, 2014.   
+[28] T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár. Focal loss for dense object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2980–2988, 2017.   
+[29] D. Liu, H. Zhang, F. Wu, and Z.-J. Zha. Learning to assemble neural module tree networks for visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4673–4682, 2019.   
+[30] X. Liu, Z. Wang, J. Shao, X. Wang, and H. Li. Improving referring expression grounding with crossmodal attention-guided erasing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1950–1959, 2019.   
+[31] J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 3431– 3440, 2015.   
+[32] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.   
+[33] J. Lu, D. Batra, D. Parikh, and S. Lee. ViLBERT: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), pages 13–23, 2019.   
+[34] J. Lu, V. Goswami, M. Rohrbach, D. Parikh, and S. Lee. 12-in-1: Multi-task vision and language representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 10437–10446, 2020.   
+[35] G. Luo, Y. Zhou, R. Ji, X. Sun, J. Su, C.-W. Lin, and Q. Tian. Cascade grouped attention network for referring expression segmentation. In ACM International Conference on Multimedia, 2020.   
+[36] G. Luo, Y. Zhou, X. Sun, L. Cao, C. Wu, C. Deng, and R. Ji. Multi-task collaborative network for joint referring expression comprehension and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   
+[37] J. Mao, J. Huang, A. Toshev, O. Camburu, A. L. Yuille, and K. Murphy. Generation and comprehension of unambiguous object descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 11–20, 2016.   
+[38] E. Margffoy-Tuay, J. C. Pérez, E. Botero, and P. Arbeláez. Dynamic multimodal instance segmentation guided by natural language queries. In European Conference on Computer Vision (ECCV), 2018.   
+[39] F. Milletari, N. Navab, and S.-A. Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In International Conference on 3D Vision (3DV), pages 565–571, 2016.   
+[40] V. K. Nagaraja, V. I. Morariu, and L. S. Davis. Modeling context between objects for referring expression understanding. In European Conference on Computer Vision (ECCV), pages 792–807, 2016.   
+[41] B. A. Plummer, L. Wang, C. M. Cervantes, J. C. Caicedo, J. Hockenmaier, and S. Lazebnik. Flickr30k entities: Collecting region-to-phrase correspondences for richer image-to-sentence models. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2641–2649, 2015.   
+[42] B. A. Plummer, P. Kordas, M. H. Kiapour, S. Zheng, R. Piramuthu, and S. Lazebnik. Conditional image-text embedding networks. In European Conference on Computer Vision (ECCV), pages 249–264, 2018.   
+[43] J. Redmon and A. Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018.   
+[44] S. Ren, K. He, R. Girshick, and J. Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 39(6): 1137–1149, 2017.   
+[45] H. Rezatofighi, N. Tsoi, J. Gwak, A. Sadeghian, I. Reid, and S. Savarese. Generalized intersection over union: A metric and a loss for bounding box regression. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 658–666, 2019.   
+[46] A. Sadhu, K. Chen, and R. Nevatia. Zero-shot grounding of objects from natural language queries. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4694–4703, 2019.   
+[47] H. Tan and M. Bansal. Lxmert: Learning cross-modality encoder representations from transformers. Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2019.   
+[48] L. Wang, Y. Li, J. Huang, and S. Lazebnik. Learning two-branch neural networks for image-text matching tasks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 41(2):394–407, 2018.   
+[49] T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz, J. Davison, S. Shleifer, P. von Platen, C. Ma, Y. Jernite, J. Plu, C. Xu, T. L. Scao, S. Gugger, M. Drame, Q. Lhoest, and A. M. Rush. Transformers: State-of-the-art natural language processing. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 38–45, 2020.   
+[50] S. Yang, G. Li, and Y. Yu. Propagating over phrase relations for one-stage visual grounding. In European Conference on Computer Vision, pages 589–605. Springer, 2020.   
+[51] Z. Yang, B. Gong, L. Wang, W. Huang, D. Yu, and J. Luo. A fast and accurate one-stage approach to visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4683–4693, 2019.   
+[52] Z. Yang, T. Chen, L. Wang, and J. Luo. Improving one-stage visual grounding by recursive sub-query construction. In European Conference on Computer Vision (ECCV), 2020.   
+[53] L. Ye, M. Rochan, Z. Liu, and Y. Wang. Cross-modal self-attention network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   
+[54] F. Yu, J. Tang, W. Yin, Y. Sun, H. Tian, H. Wu, and H. Wang. Ernie-vil: Knowledge enhanced visionlanguage representations through scene graph. arXiv preprint arXiv:2006.16934, 2020.   
+[55] L. Yu, P. Poirson, S. Yang, A. C. Berg, and T. L. Berg. Modeling context in referring expressions. In European Conference on Computer Vision (ECCV), pages 69–85, 2016.   
+[56] L. Yu, Z. Lin, X. Shen, J. Yang, X. Lu, M. Bansal, and T. L. Berg. Mattnet: Modular attention network for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1307–1315, 2018.   
+[57] Z. Yu, J. Yu, C. Xiang, Z. Zhao, Q. Tian, and D. Tao. Rethinking diversified and discriminative proposal generation for visual grounding. International Joint Conference on Artificial Intelligence (IJCAI), 2018.   
+[58] X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai. Deformable detr: Deformable transformers for end-to-end object detection. In International Conference on Learning Representations (ICLR), 2021.

parse/train/j7u7cJDBo8p/j7u7cJDBo8p_content_list.json

@@ -0,0 +1,1058 @@
+[
+    {
+        "type": "text",
+        "text": "Referring Transformer: A One-step Approach to Multi-task Visual Grounding ",
+        "text_level": 1,
+        "bbox": [
+            204,
+            122,
+            795,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Muchen Li1,2 muchenli@cs.ubc.ca ",
+        "bbox": [
+            292,
+            224,
+            457,
+            253
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Leonid Sigal1,2,3,4 lsigal@cs.ubc.ca ",
+        "bbox": [
+            547,
+            224,
+            684,
+            255
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Department of Computer Science, University of British Columbia   \n2Vector Institute for AI 3CIFAR AI Chair 4NSERC CRC Chair ",
+        "bbox": [
+            263,
+            258,
+            735,
+            287
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            323,
+            535,
+            339
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "As an important step towards visual reasoning, visual grounding (e.g., phrase localization, referring expression comprehension / segmentation) has been widely explored. Previous approaches to referring expression comprehension (REC) or segmentation (RES) either suffer from limited performance, due to a two-stage setup, or require the designing of complex task-specific one-stage architectures. In this paper, we propose a simple one-stage multi-task framework for visual grounding tasks. Specifically, we leverage a transformer architecture, where two modalities are fused in a visual-lingual encoder. In the decoder, the model learns to generate contextualized lingual queries which are then decoded and used to directly regress the bounding box and produce a segmentation mask for the corresponding referred regions. With this simple but highly contextualized model, we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefits greatly from contextualized information and multi-task training. ",
+        "bbox": [
+            233,
+            356,
+            766,
+            563
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            589,
+            310,
+            607
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Multi-modal grounding1 tasks (e.g., phrase localization [1, 3, 9, 41, 48], referring expression comprehension [17, 19, 24, 26, 29, 30, 37, 51, 52, 55, 56] and segmentation [6, 18, 20, 21, 29, 38, 53, 56]) aim to generalize traditional object detection and segmentation to localization of regions (rectangular or at a pixel level) in images that correspond to free-form linguistic expressions. These tasks have emerged as core problems in vision and ML due to the breadth of applications that can make use of such techniques, spanning image captioning, visual question answering, visual reasoning and others. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            705
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The majority of multi-modal grounding architectures, to date, take the form of two-stage approaches, inspired by Faster RCNN [44] and others, which first generate a set of image region proposals and then associate/ground one, or more, of these regions to a phrase by considering how well the content matches the query phrase. Context among the regions and multiple query phrases, which often come parsed from a single sentence, has also been considered in various ways (e.g., using LSTM stacks [9], graph neural networks [1] and others). More recent variants leverage pre-trained multi-modal Transformers (e.g., ViLBERT [33, 34]) to fine-tune to the grounding tasks. Such models have an added benefit of being able to learn sophisticated cross-modal feature representations from external large-scale data, which further improve the performance. However, a significant limitation of all such two-stage methods is their inability to condition the proposal mechanism on the query phrase itself, which inherently limits the upper bound of performance (see Table 3 in [51]). ",
+        "bbox": [
+            174,
+            712,
+            825,
+            823
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To address these limitations, more recently, a number of one-stage approaches have been introduced [22, 36, 51, 52]. Most of these take inspiration from Yolo [43] and the variants, and rely on more integrated visual-linguistic fusion and a dense anchoring mechanism to directly predict the grounding regions. While this alleviates the need for a proposal stage, it instead requires somewhat ad hoc anchor definitions, often obtained by clustering of labeled regions, and also limits ability to contextualize grounding decisions as each query phrase is effectively processed independently. Finally, little attention in the literature has been given to leveraging relationship among the REC and RES tasks. ",
+        "bbox": [
+            174,
+            140,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work we propose an end-to-end one-stage architecture, inspired by the recent DETR [2] detection framework, which is capable of simultaneous language grounding at both a boundingbox and segmentation level, without requiring dense anchor definitions. This model also enables contextualized reasoning by taking into account the entire image, all referring query phrases of interest and (optionally) lingual context (e.g., a sentence from which referring phrases are parsed). Specifically, we leverage a transfomer architecture, with a visual-lingual encoder, to encode image and lingual context, and a two-headed (detection and segmentation) custom contextualized tranformer decoder. The contextualized decoder takes as input learned contextualized phrase queries and decodes them directly to bounding boxes and segmentation masks. Implicit 1-to-1 correspondence between input referring phrases and resulting outputs also enables a more direct formulation of the loss without requiring Hungarian matching. With this simple model we outperform state-of-the-art methods by a large margin on both REC and RES tasks. We also show that a simple pre-training schedule (on an external dataset) further improves the performance. Extensive experiments and ablations illustrate that our model benefit greatly from the contextualized information and the multi-task training. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            435
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Contributions. Our contributions are: (1) We propose a simple and general one-stage transformerbased architecture for referring expression comprehension and segmentation. The core of this model is the novel transformer decoder that leverages contextualized phrase queries and is able to directly decode those, subject to contextualized image embeddings, into corresponding image regions and segments; (2) Our approach is unique in enabling simultaneous REC and RES using a single trained model (the only other method capable of this is [36]); showing that such multi-task learning leads to improvements on both tasks; (3) As with other transformer-based architectures, we show that pre-training can further improve the performance and both vanila and pre-trained models outperform state-of-the-art on both tasks by significant margins (up to $8 . 5 \\%$ on RefCOCO dataset for REC and $1 9 . 4 \\%$ for RES). We also thoroughly validate our design in detailed ablations. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            580
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related works ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            599,
+            325,
+            616
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Referring Expression Comprehension (REC). REC focuses on producing an image bounding box tightly encompassing a language query. Previous two-staged works [17, 19, 29, 30, 56] reformulate this as a ranking task with a set of candidate regions predicted from a pre-trained proposal mechanism. Despite achieving great success, the performance of two-staged methods is capped by the speed and accuracy of region proposals in the first stage. More recently, one-stage approaches [26, 51, 52] have been used to alleviate the aforementioned limitations. Yang et al. [51, 52] proposed to fuse query information with visual features and pick the bounding box with maximum activation scores from YOLOv3 [43]. Yang et al. [50] explore language structure guided propagation in the context of one stage grounding. Liao et al. [26] utilizes CenterNet [11] to perform correlation filtering for region center localization. However, such methods either require manually tuned anchor boxes or suffer from semantic loss due to modality misalignment. In contrast, our model learns to better align modalities using a cross-modal transformer and directly decode bounding boxes for each query. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            794
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Referring Expression Segmentation (RES). Similar to REC, RES, proposed in [18], aims to predict segmentation masks to better describe the shape of the referred region. A typical solution for referring expression segmentation is to fuse multi-modal information with a segmentation network (e.g., [16, 31]) and train it to output the segmented masks [18, 29, 38, 53, 56]. More recent approaches focus on designing module to enable better multi-modal interactions, e.g., progressive multi-scale fusion used in [21] and cross-modal attention block used in [20]. Since localization information matters in predicting instance segmentations (as noted in Mask RCNN [16]), very recent work [22] aims to explicitly localize object before doing segmentation. Despite the relatively high performance being achieved in RES, existing approaches still struggle to determine the correct referent region and tend to output noisy segmentation results with an irregular shape, while our model is able to produce segmentations with fine-grained shapes even on challenging scenarios with occlusions or shadows. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            133
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Multi-task Learning for REC and RES. Multi-task learning is widely applied in object detection and segmentation [2, 16], often, by leveraging shared backbone and task-specific heads. Building on this idea, Luo et al. [36] proposed a multi-task collaborative network (MCN) to jointly address REC and RES. They introduce consistency energy maximization loss that constrains the feature activation map in REC and RES to be similar. While our model is also set up to learn REC and RES tasks jointly, we argue that an explicit constraint tends to downplay the quality of the final predicted mask since the feature map from the REC branch can blur out fine-grained region shape information needed by the RES branch (see Figure 2). Hence, we use an implicit constraint where tasks head of REC and RES are trained to output corresponding bounding box and mask from the same joint multi-modal representation. We illustrate that our model can benefit from multi-task supervision, leading to more accurate results as compared to single-task variants. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pretrained Multi-modal Transformers. Transformer-based pretrained models [5, 12, 33, 47, 54] have recently showed strong potential in multi-modal understanding. LXMERT [47] and ViLBERT [33] use two stream transformers with cross-attention transformer layers on top for multimodal fusion. More recent works, [5, 12] advocate a single-stream design to fuse two modalities earlier. The success of the aforementioned models can largely be attributed to the cross-modal representations obtained by multi-task pretraining on a large amount of aligned image-text pairs. Despite state-of-the-art performance of such models on the downstream REC task, these models, fundamentally, are still a form of a two-stage pipeline where image features are extracted using pretrained detectors or proposal mechanisms. We focus on a one-stage architecture variant that allows visual and lingual features to be aligned at the early stages. Although the focus of our work is not to design a better pretraining scheme, we show that our model can outperform the existing state-of-the-art with proper pretraining. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Transformer-based Detectors. More recently, DETR [2] and its variants [13, 58], were proposed to enable end-to-end object detection. DETR reformulates detection as a set prediction tasks and uses transformers to decode learnable queries to bounding boxes. Despite state-of-art performance, DETR is disadvantaged by its optimization difficulty and, usually, extra-long training time. While adopting a similar pipeline, our model focus on aligning different modalities to generate contextualized expression-specific referring queries. We also design our model to get rid of Hungarian matching loss by leveraging one-to-one correspondences between predicted bounding boxes and referring expressions, which leads to faster convergence for our model. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Approach ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            582,
+            289,
+            599
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Given an image $\\mathcal { T }$ and a set of query phrases $\\mathcal { Q } _ { p } = \\{ \\mathbf { p } _ { i } \\} _ { i = 1 , \\dots , M }$ , that we assume to come from an (optional) contextual text source2 $\\mathcal { Q }$ , our goal is to predict a set of bounding boxes $B = \\{ \\mathbf { b } _ { i } \\} _ { i = 1 , \\dots , M }$ and corresponding segmentation masks ${ \\cal S } = \\{ { \\bf s } _ { i } \\} _ { i = 1 , \\dots , M }$ , one for each query phrase $i$ that localizes that phrase in the image. Note, $M$ is the number of phrases / referring expressions for a given image $\\mathcal { T }$ and is typically between 1 and 16 for the Flick $3 0 \\mathrm { k }$ [41] dataset. ",
+        "bbox": [
+            174,
+            608,
+            823,
+            680
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 1, our referring transformer is composed of four components. Given an image(con)text pair, $<  { \\mathcal { T } } ,  { \\mathcal { Q } } >$ , a cross-modal encoder generates joint image-text embeddings for each visual and textual token – feature columns and word embeddings respectively. Query phrases $\\mathcal { Q } _ { p }$ and image-text embeddings are then fed into a query encoder which produces query phrase embeddings. The decoder jointly reasons across all these query phrase embeddings and decodes multi-task feature, which is then sent to the detection and segmentation head to produce a set of boxes $\\boldsymbol { B }$ and masks $s$ The result is a one-staged end-to-end model that solves the REC and RES tasks at the same time. We will now introduce constituent architectural components for the four stages briefly described above. ",
+        "bbox": [
+            174,
+            685,
+            825,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Feature Extraction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            344,
+            830
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Visual & Text Backbone. Starting from an initial image $\\mathcal { T } \\in \\mathbb { R } ^ { 3 \\times H _ { 0 } \\times W _ { 0 } }$ , we adopt the widely used ResNet [15] to generate its low-resolution feature map $\\mathbf { f } _ { I } \\in \\mathbb { R } ^ { C _ { i } \\times H W }$ . For the corresponding expression or sentence, we use the uncased base of BERT [8] to obtain the representation $\\mathbf { f } _ { Q } \\in$ $\\mathbb { R } ^ { C _ { t } \\times N }$ , while $N$ is the length of the input context sentence. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/e40ae0a0b3ed22270911f094dd1b90cc0e55acb591f3e2843ed7485181a3033e.jpg",
+        "image_caption": [
+            "Figure 1: Referring Transformer. An overview of the proposed architecture is shown in (a). For an image and (con)text input, a visual-lingual encoder is used to refine image features, extracted from a convolutional backbone, and lingual features, extracted by a BERT. A query encoder and decoder produce features for REC and RES heads, given multi-modal features and query phrases. The detailed structure of the query encoder and decoder is shown in (b). Colored squares denote embeddings for corresponding query phrases. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            90,
+            816,
+            314
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            417,
+            821,
+            448
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Visual-Lingual Encoder. The visual-lingual encoder is designed to fuse information from multimodal sources. For cross-modality encoding, we use a transformer encoder based model, which is composed of 6 transformer encoder layers. Specifically, given both image and text features, multi-layer perceptrons are applied first to project different modalities to a joint embedding space with a hidden dimension of $C$ . To provide transformer encoders with positional information, we follow [2, 8] to add cosine positional embedding $P _ { i m g }$ for image features and learnable positional embedding $P _ { t e x t }$ for text features. We then concatenate the projected features into a single sequence $\\mathbf { f } ~ \\in ~ \\mathbb { R } ^ { C \\times ( H W + N ) }$ . To distinguish between modalities, we also deign a learnable modal label embedding $E _ { l a b e l } : \\{ E _ { i m g } , E _ { t e x t } ^ { - } \\}$ which is added to the original sequences. The visual-lingual encoder then takes a sequence as input, and $\\{ P _ { i m g } , P _ { t e x t } , E _ { l a b e l } \\}$ are fed into each encoder layer. The encoder output is a multi-modal feature sequence $\\mathbf { f } _ { v l } \\in \\mathbb { R } ^ { C \\times ( H W + N ) }$ . ",
+        "bbox": [
+            173,
+            454,
+            825,
+            609
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Query Encoder and Decoder ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            411,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The query encoder and decoder aims to encode / decode query phrases, conditioned on visual-lingual features from the encoder, into an output bounding box and segmentation. In this stage, we first generate embeddings corresponding to each query phrase. These query phrase embeddings are then fed into the decoder together with the visual-lingual features from the encoder to generate outputs. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Encoding Query Phrases. To enable the decoder to generate the desired output (bounding box and/or segmentation) the queries must encode several bits of crucial information. Mainly, (1) encoding of the query phrases, (2) image encoding and (3) phrase-specific optional (con)text information. For phrase encoding in (1) we use a BERT model with pooling heads which share weights with (con)text encoder; this results in the phrase feature vector $\\mathbf { f _ { p } } _ { i } \\in \\mathbb { R } ^ { C }$ for the $i$ -th referring phrase. We note that because we use visual-lingual encoder, (2) and (3) are jointly encoded in multi-modal features $\\mathbf { f } _ { v l }$ described in Section 3.1 above. However, $\\mathbf { f } _ { v l }$ is phrase-agnostic encoding of the image and (con)text. To generate phrase-specific context, given a phrase $\\mathbf { p } _ { i }$ , average pooling is used to extract the phrase-specific context information $\\mathbf { f } _ { c } ( \\mathbf { p } _ { i } )$ from the visual-lingual feature sequence as follows: ",
+        "bbox": [
+            173,
+            712,
+            825,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2e90a85e446958d0263727e66978780d9c6e97128c1945208a61a1ccb2a6aab.jpg",
+        "text": "$$\n\\mathbf { f } _ { c } ( \\mathbf { p } _ { i } ) = \\frac { \\sum \\mathbf { f } _ { v l } [ l _ { \\mathbf { p } _ { i } } : r _ { \\mathbf { p } _ { i } } ] } { r _ { \\mathbf { p } _ { i } } - l _ { \\mathbf { p } _ { i } } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            845,
+            583,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $l _ { \\mathbf { p } _ { i } }$ and $r _ { \\mathbf { p } _ { i } }$ denotes the left and right bounds of phrase $\\mathbf { p } _ { i }$ in the original (con)text sentence. Finally, given phrase encoding $\\mathbf { f _ { p } } _ { i }$ and phrase-specific context $\\mathbf { f } _ { c } ( \\mathbf { p } _ { i } )$ we construct our phrase queries ",
+        "bbox": [
+            173,
+            883,
+            823,
+            912
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "using a multi-later perceptron: ",
+        "bbox": [
+            174,
+            92,
+            374,
+            106
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a7e972d95010fe1816927ef162a16a71463820f5e002b9992c2e318c810ad631.jpg",
+        "text": "$$\n\\widehat { Q _ { { \\bf p } i } } = \\mathtt { M L P } \\left( [ { \\bf f } _ { c } ( { \\bf p } _ { i } ) ; { \\bf f _ { p } } _ { i } ] \\right) + E _ { p } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            111,
+            606,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $E _ { p } \\in \\mathbb { R } ^ { C }$ is a learnable embedding which serves as a bias to the formed query. ",
+        "bbox": [
+            166,
+            138,
+            732,
+            154
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Decoding. In the decoder, self attention layers are used to enable information flow in a dense connected graph of phrase queries. This allows phrase queries to contextualize and refine each other; the inspiration for this step is taken from [1]. After that, a cross attention layer decodes visual-lingual information given the updated phrase query and feature sequence from the encoder. The design of our decoder is similar to the transformer decoder, except attention is non-causal. ",
+        "bbox": [
+            174,
+            159,
+            825,
+            229
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 Multi-task training ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            244,
+            348,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we demonstrate how the decoded phrase-specific query features can be naturally used to train multiple heads for different referring tasks (regression for REC and segmentation for RES). ",
+        "bbox": [
+            174,
+            270,
+            823,
+            299
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Referring Comprehension/Detection (REC). For referring detection tasks, the final output is computed by a simple two-layer perceptron over the decoded phrase-specific query features. We let the detection head directly output center coordinates $\\tilde { \\mathbf { b } } = ( x , y , h , w )$ for the referred image. To supervise the training, we use a weighted sum of an L1 loss and a Generalized IOU loss [45]: ",
+        "bbox": [
+            173,
+            304,
+            825,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7ea9297155a964ddb353e7cc07414bc35845c0b4ae41fa86e3421fff6e0be1aa.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { d e t } = \\lambda _ { i o u } \\mathcal { L } _ { i o u } ( \\mathbf { b } , \\tilde { \\mathbf { b } } ) + \\lambda _ { L 1 } | | \\mathbf { b } - \\tilde { \\mathbf { b } } | | _ { 1 } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            368,
+            635,
+            387
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The $\\lambda _ { i o u }$ and $\\lambda _ { L 1 }$ control the relative weighting of the two losses in the REC objective. ",
+        "bbox": [
+            173,
+            393,
+            741,
+            409
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Referring Segmentation (RES). Following previous work [2], we design an FPN-like architecture to predict a referring segmentation mask for each phrase expression. Attention masks from the decoder and image features from the visual-lingual encoder are concatenated as the FPN input, while features from different stages of image backbones are used as skip connections to refine the final output. The last linear layer project the upsampled feature to a single channel heatmap and a sigmoid function is used to map the feature to mask scores $\\tilde { \\mathbf { s } } \\in \\mathbb { R } ^ { H _ { 0 } / 4 \\times W _ { 0 } / 4 }$ . The loss for training RES task is: ",
+        "bbox": [
+            173,
+            412,
+            825,
+            511
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/466a7fada956653e94f48a3f0d9f757580f9b7da25dd7e13ff9bf3b38ad226a6.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathcal { L } _ { s e g } = \\lambda _ { f o c a l } \\mathcal { L } _ { f o c a l } ( \\mathbf { s } , \\tilde { \\mathbf { s } } ) + \\lambda _ { d i c e } \\mathcal { L } _ { d i c e } ( \\mathbf { s } , \\tilde { \\mathbf { s } } ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            346,
+            511,
+            650,
+            529
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Here $\\mathcal { L } _ { f o c a l }$ is the focal loss for classifying pixels used in [28], $\\mathcal { L } _ { d i c e }$ is the DICE/F-1 loss proposed in [39]; $\\lambda _ { f o c a l }$ and $\\lambda _ { d i c e }$ are hyper-parameters controlling the relative importance of the two losses. ",
+        "bbox": [
+            171,
+            530,
+            823,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Joint Training. While it is possible to train referring segmentation and referring detection tasks separately, we find that joint training is highly beneficial. Therefore the combined training loss which we optimize is $\\mathcal { L } = \\mathcal { L } _ { s e g } + \\mathcal { L } _ { d e t }$ . ",
+        "bbox": [
+            174,
+            564,
+            823,
+            608
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pretraining the Transformer. Transformers are generally data hungry and requires a lot of data to train [5, 33]. Although in this paper we do not use a large pretraining model and a lot of data. We found that simple pretraining strategy on the region description splits of Visual-Genome dataset [25] makes our model achieve comparable and even better performance against some of state-of-the-art pretrained models. Interestingly, we found that although there is no ground truth segmentation provided in Visual-Genome, the RES task can still benefit greatly from pretrained models, likely due to the fine-tuned multi-task representation. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            710
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            312,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Datasets ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            747,
+            272,
+            762
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "RefCOCO/RefCOCO $^ +$ /RefCOCOg (REC&RES). RefCOCO, RefCOCO $^ +$ [55] and RefCOCOg [40] are collections of images and referred objects from MSCOCO [27]. On RefCOCO and Ref$\\mathrm { C O C O + }$ we follow the split used in [55] and report scores on the validation, testA and testB splits. On RefCOCOg, we use the RefCOCO-umd splits proposed in [40]. ",
+        "bbox": [
+            174,
+            772,
+            826,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Flickr30k Entities (REC). Flickr30k Entities [41] contains 31,783 images and $1 5 8 \\mathrm { k }$ caption sentences with 427k annotated phrase. We use splits from [41, 42]. Bounding boxes and phrase annotations are consistent with the previous one-stage approaches [51, 52] for fair comparisons. ",
+        "bbox": [
+            174,
+            834,
+            825,
+            877
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ReferIt (REC). The ReferItGame dataset [24] contains 20,000 images. We follow setup in [3] for splitting train, validation and test set; resulting in 54k, 6k and 6k referring expressions respectively. ",
+        "bbox": [
+            173,
+            882,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe6ad8c71f4e1ea98a00788df050322d5fad0606b76dc406574e4f9a44fec78c.jpg",
+        "table_caption": [
+            "Table 1: Comparison on REC task. Performance on RefCOCO/RefCOCO+/RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 and RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td rowspan=\"2\">Visual Features</td><td rowspan=\"2\">Pretrain Images</td><td rowspan=\"2\">Multi- task</td><td colspan=\"3\">RefCOCO</td><td colspan=\"3\">RefCOCO+</td><td rowspan=\"2\">RefCOCOg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB val-u</td></tr><tr><td>Two-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>CMN[19]</td><td>VGG16</td><td>None</td><td>×</td><td>-</td><td>71.03</td><td>65.77</td><td>-</td><td>54.32</td><td>47.76</td><td>-</td><td>-</td></tr><tr><td>RvG-Tree [17]</td><td>RN101</td><td>None</td><td>×</td><td>75.06</td><td>78.61</td><td>69.85</td><td>63.51</td><td>67.45</td><td>56.66</td><td>66.95</td><td>66.51</td></tr><tr><td>CM-Att-Erase [30]</td><td>RN101</td><td>None</td><td>×</td><td>78.35</td><td>83.14</td><td>71.32</td><td>68.09</td><td>73.65</td><td>58.03</td><td>67.99</td><td>68.67</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>None</td><td>√</td><td>76.65</td><td>81.14</td><td>69.99</td><td>65.33</td><td>71.62</td><td>56.02</td><td>66.58</td><td>67.27</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>None</td><td>√</td><td>76.41</td><td>81.21</td><td>70.09</td><td>66.46</td><td>72.02</td><td>57.52</td><td>65.87</td><td>66.44</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>None</td><td>×</td><td>-</td><td>81.06</td><td>71.85</td><td>-</td><td>70.35</td><td>56.32</td><td>-</td><td>65.73</td></tr><tr><td>SSG [4]</td><td>DN53</td><td>None</td><td>×</td><td>=</td><td>76.51</td><td>67.50</td><td>-</td><td>62.14</td><td>49.27</td><td>58.80</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>None</td><td>×</td><td>72.54</td><td>74.35</td><td>68.50</td><td>56.81</td><td>60.23</td><td>49.60</td><td>61.33</td><td>60.36</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>None</td><td>×</td><td>77.63</td><td>80.45</td><td>72.30</td><td>63.59</td><td>68.36</td><td>56.81</td><td>67.30</td><td>67.20</td></tr><tr><td>MCN[36]</td><td>DN53</td><td>None</td><td>√</td><td>80.08</td><td>82.29</td><td>74.98</td><td>67.16</td><td>72.86</td><td>57.31</td><td>66.46</td><td>66.01</td></tr><tr><td>Ours</td><td>RN50</td><td>None</td><td>√</td><td>81.82</td><td>85.33</td><td>76.31</td><td>71.13</td><td>75.58</td><td>61.91</td><td>69.32</td><td>69.10</td></tr><tr><td>Ours</td><td>RN101</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>VilBERT[33]</td><td>RN101</td><td>3.3M</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td></td><td>RN101</td><td></td><td>×</td><td>-</td><td>=</td><td>-</td><td>72.34</td><td>78.52</td><td>62.61</td><td>1</td><td>-</td></tr><tr><td>ERNIE-ViL_L[54]</td><td>RN101</td><td>4.3M 4.6M</td><td>×</td><td>=</td><td></td><td></td><td>75.89</td><td>82.37</td><td>66.91</td><td></td><td></td></tr><tr><td>UNTIER_L[5]</td><td>RN101</td><td>4.6M</td><td>×</td><td>81.41</td><td>87.04</td><td>74.17</td><td>75.90</td><td>81.45</td><td>66.70</td><td>74.86</td><td>75.77</td></tr><tr><td>VILLA_L[12]</td><td>RN50</td><td></td><td>×</td><td>82.39</td><td>87.48</td><td>74.84</td><td>76.17</td><td>81.54</td><td>66.84</td><td>76.18</td><td>76.71</td></tr><tr><td>Ours*</td><td></td><td>100k</td><td>√</td><td>85.43</td><td>87.48</td><td>79.86</td><td>76.40</td><td>81.35</td><td>66.59</td><td>78.43</td><td>77.86</td></tr><tr><td>Ours*</td><td>RN101</td><td>100k</td><td>√</td><td>85.65</td><td>88.73</td><td>81.16</td><td>77.55</td><td>82.26</td><td>68.99</td><td>79.25</td><td>80.01</td></tr></table>",
+        "bbox": [
+            187,
+            140,
+            805,
+            387
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 Implementing Details ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            362,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We train our model with AdamW [32]. The initial learning rate is set to 1e-4 while the learning rate of image backbone and context encoder is set to 1e-5. We initialized weights in the transformer encoder and decoder with Xavier initialization [14]. For image backbone, we experiment with the popular ResNet-50 and ResNet-101 networks [15] where weights are initialized from corresponding ImageNet-pretrained models. For the context encoder and phrase encoder, we use an uncased version of BERT model [8] with weights initialized from pretrained checkpoints provided by HuggingFace [49]. For data augmentation, we scale images such that the longest side is 640 pixels and follow [51] to do random intensity saturation and affine transforms. We remove the random horizontal flip augmentation used in previous work [51] since we notice it causes semantic ambiguity on RefCOCO, likely due to relative location (e.g., left of/right of) specific queries in the dataset. ",
+        "bbox": [
+            173,
+            438,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On Flickr30k dataset, we set the maxium length of context sentence to 90 and maximum number of referring phrases to 16. On the ReferIt and the RefCOCO dataset, only phrase expressions are provided and the task aims to predict a single bounding box for each of the expressions. In those cases, the context sentence is taken as the referring phrase expression itself. We set the maximum length of context sentence on these two datasets to 40. To fairly compare with pretrained methods, we use region description split in the VisualGenome [25] to pretrain our model. The dataset contains approximately $1 0 0 \\mathrm { k }$ images and we remove the images that appear in Flickr30k Entities and RefCOCO/RefCOCOg/RefCOCO+’s validation and test set to avoid potential test data leak. For all the pretrained methods, we train the model on pretraining dataset for 6 epoches. We find that longer pretraining schedule gives better performance, but since the focus of this paper is not on pretraining methods, we stick to shorter pretraining schedules to save computational resources. All experiments are conducted using 4 Nvidia 2080TI GPU with batch size as 32. For all the results given, we run experiments several times with random seeds and the error bars are within $\\pm 0 . 5 \\%$ . ",
+        "bbox": [
+            174,
+            583,
+            825,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 Quantitative Analysis ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            781,
+            362,
+            796
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation Metrics. For referring expression comprehension (REC), consistent with prior works, we use precision as the evaluation metric. We mark a referring detection as correct when the intersection-over-union (IoU) between the predicted bounding box and ground truth is larger than 0.5. For referring expression segmentation (RES), we reported the Mean IoU (MIoU) between the predicted segmentation mask and ground truth mask. ",
+        "bbox": [
+            174,
+            808,
+            825,
+            877
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "REC and RES on RefCOCO/RefCOCO $+$ /RefCOCOg. Our model addresses REC and RES tasks jointly. We compare their respective performances with the state-of-the-art in Table 1 and 2. ",
+        "bbox": [
+            173,
+            882,
+            820,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7b6d9ab4f318c2df954e6974ae07467e62e3ebb51838ea47c231e15ae55d7e80.jpg",
+        "table_caption": [
+            "Table 2: Comparison on RES tasks. Performance on RefCOCO/RefCOCO $+$ /RefCOCOg datasets [55] is reported. Ours∗ denotes that pretraining is used. RN50 abd RN101 refer to ResNet50 and ResNet101 [15] respectively; DN53 refers to DarkNet53 [43] backbone. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Methods</td><td rowspan=\"2\">Backbone</td><td colspan=\"3\">RefCOCO</td><td colspan=\"3\">RefCOCO+</td><td colspan=\"2\">RefCOCOg</td><td rowspan=\"2\">Inference time(ms)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td><td>val</td><td>test</td></tr><tr><td>DMN [38]</td><td>RN101</td><td>49.78</td><td>54.83</td><td>45.13</td><td>38.88</td><td>44.22</td><td>32.29</td><td>-</td><td>-</td><td>-</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>56.51</td><td>62.37</td><td>51.70</td><td>46.67</td><td>52.39</td><td>40.08</td><td>47.64</td><td>48.61</td><td>378</td></tr><tr><td>NMTree [29]</td><td>RN101</td><td>56.59</td><td>63.02</td><td>52.06</td><td>47.40</td><td>53.01</td><td>41.56</td><td>46.59</td><td>47.88</td><td>1</td></tr><tr><td>Lang2seg [6]</td><td>RN101</td><td>58.90</td><td>61.77</td><td>53.81</td><td>-</td><td>-</td><td>-</td><td>46.37</td><td>46.95</td><td></td></tr><tr><td>BCAM[20]</td><td>RN101</td><td>61.35</td><td>63.37</td><td>59.57</td><td>48.57</td><td>52.87</td><td>42.13</td><td>-</td><td>=</td><td></td></tr><tr><td>CMPC[21]</td><td>RN101</td><td>61.36</td><td>64.53</td><td>59.64</td><td>49.56</td><td>53.44</td><td>43.23</td><td>=</td><td>=</td><td>=</td></tr><tr><td>MCN+ASNLS [36]</td><td>DN53</td><td>62.44</td><td>64.20</td><td>59.71</td><td>50.62</td><td>54.99</td><td>44.69</td><td>49.22</td><td>49.40</td><td>56</td></tr><tr><td>CGAN [35]</td><td>DN53</td><td>64.86</td><td>68.04</td><td>62.07</td><td>51.03</td><td>55.51</td><td>44.06</td><td>51.01</td><td>51.69</td><td>-</td></tr><tr><td>LTS [22]</td><td>DN53</td><td>65.43</td><td>67.76</td><td>63.08</td><td>54.21</td><td>58.32</td><td>48.02</td><td>54.40</td><td>54.25</td><td>1</td></tr><tr><td>Ours</td><td>RN50</td><td>69.94</td><td>72.80</td><td>66.13</td><td>60.9</td><td>65.20</td><td>53.45</td><td>57.69</td><td>58.37</td><td>38</td></tr><tr><td>Ours</td><td>RN101</td><td>70.56</td><td>73.49</td><td>66.57</td><td>61.08</td><td>64.69</td><td>52.73</td><td>58.73</td><td>58.51</td><td>41</td></tr><tr><td>Ours*</td><td>RN50</td><td>73.61</td><td>75.22</td><td>69.80</td><td>65.30</td><td>69.69</td><td>56.98</td><td>65.70</td><td>65.41</td><td>38</td></tr><tr><td>Ours*</td><td>RN101</td><td>74.34</td><td>76.77</td><td>70.87</td><td>66.75</td><td>70.58</td><td>59.40</td><td>66.63</td><td>67.39</td><td>41</td></tr></table>",
+        "bbox": [
+            207,
+            137,
+            789,
+            295
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/ae52ea765ab73627d130406f12ccbc83f1847c53fe2d5875520aa3f4dee6d22d.jpg",
+        "image_caption": [
+            "Figure 2: Qualitative Evaluation. In (a) comparison to MCN [36] on REC is shown; orange, blue and red bounding boxes correspond to outputs from MCN, our model and the ground truth. In (b) similar comparison on RES is made. The attention map is drawn from the last layer of the decoder. We add mosaic to all human face to protect personal information. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            323,
+            807,
+            585
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, the model is first compared with previous one-stage and two-stage approaches for REC. Without bells and whistles, we observe a consistent performance boost of $+ 2 . 7 \\% / + 4 \\% / + 2 . 1 \\%$ on RefCOCO, $+ 6 . 6 \\% / + 4 . 3 \\% / + 8 . 5 \\%$ on $\\operatorname { R e f C O C O + }$ and $+ 4 . 4 \\% / + 5 . 1 \\%$ on RefCOCOg. To compare with pretrained BERT methods, we use the pretraining strategy discussed in Section 3.3. As results show, our model achieves comprehensive advantage and shows distinct improvement on some splits, even compared to advance BERT models that use $4 0 \\times$ more data in pretraining. Table 2 illustrates results on RES task in terms of MIoU score. It can be seen that our model achieves the best performance; substantially better than the state-of-art. We further observe that pretraining on the REC task gives a huge performance boost to the RES task, even when no segmentation mask is used in pre-training. Multi-task training enables the model to leverage performance boost in one task to improve the other. ",
+        "bbox": [
+            173,
+            683,
+            825,
+            835
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We show the inference time for our model in Table 2. Our model can directly decode all query phrases in an image in parallel, allowing it to reach real-time performance. Importantly, note the corresponding scores for our model in Table 1 and Table 2 are based on the output of a single multitask model that predicts referring detection box and segmentation mask simultaneously. The only related work that shares this property is the MCN [36], which has substantially inferior performance. ",
+        "bbox": [
+            174,
+            842,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2f7d735b2d283889a4ea7c36cfc744f5cda137142070389476e1db0424a715ec.jpg",
+        "table_caption": [
+            "Table 3: Comparison with State-of-The-Art Methods. Table illustrates performance on the test set of ReferItGame [24] and Flickr30K Entities [41] datasets in terms of top-1 accuracy $( \\% )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Models</td><td>Backbone</td><td>ReferItGame test</td><td>Flickr30K test</td><td>Inference time on Flickr30k(ms)</td></tr><tr><td colspan=\"5\">Two-stage</td></tr><tr><td>MAttNet [56]</td><td>RN101</td><td>29.04</td><td>-</td><td>320</td></tr><tr><td>Similarity Net [48]</td><td>RN101</td><td>34.54</td><td>60.89</td><td>184</td></tr><tr><td>CITE [42]</td><td>RN101</td><td>35.07</td><td>61.33</td><td>196</td></tr><tr><td>DDPN[57]</td><td>RN101</td><td>63.00</td><td>73.30</td><td>-</td></tr><tr><td colspan=\"5\">One-stage</td></tr><tr><td>SSG[4]</td><td>DN53</td><td>54.24</td><td>-</td><td>25</td></tr><tr><td>ZSGNet [46]</td><td>RN50</td><td>58.63</td><td>58.63</td><td>-</td></tr><tr><td>FAOA [51]</td><td>DN53</td><td>60.67</td><td>68.71</td><td>23</td></tr><tr><td>RCCF[26]</td><td>DLA34</td><td>63.79</td><td>-</td><td>25</td></tr><tr><td>ReSC-Large [52]</td><td>DN53</td><td>64.60</td><td>69.28</td><td>36</td></tr><tr><td>Ours</td><td>RN50</td><td>70.81</td><td>78.13</td><td>37(14)</td></tr><tr><td>Ours</td><td>RN101</td><td>71.42</td><td>78.66</td><td>40(15)</td></tr><tr><td>Ours*</td><td>RN50</td><td>75.49</td><td>79.46</td><td>37(14)</td></tr><tr><td>Ours*</td><td>RN101</td><td>76.18</td><td>81.18</td><td>40(15)</td></tr></table>",
+        "bbox": [
+            305,
+            123,
+            692,
+            291
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REC on Flickr30k-Entities. For Flickr30k dataset, previous one-stage works [51, 52] extract short phrases from sentences and treated them as separate referring expression comprehension tasks. We argue that in this setting, queries are mostly short phrases and therefore cannot well reflect the model’s ability to comprehend them in context. In contrast, our model, given an image and a caption (con)text sentence, aims to predict bounding boxes for all referred entities in the sentence. Doing so gives several advantages: 1. We are able to contextualize referring expressions given all other referring expressions and (con)text provided by the sentence. 2. Locations for all phrases can be inferred in one forward pass of the network, which saves a lot of computation as compared to previous one-stage approaches [51, 52] that process one phrase at a time. Note that our task formulation is consistent with some two-stage models [1, 9], but is unique for a one stage approach. ",
+        "bbox": [
+            173,
+            318,
+            825,
+            457
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Table 3 we compare our results with state-of-the-art methods. Without pretraining, we obtain a huge performance boost compared to both previous one-stage $( + 1 3 . 5 4 \\% )$ and two-stage $( + 7 . 3 1 \\% )$ state-of-the art methods. By using pretrained models, we observe that our model tends to generalize better on the test set and gives even better performance. We also provide comparison of inference time both per image and (per-expression), since our model can amortize inference across expressions. Per-expression, our inference time is substantially lower than all prior methods. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REC on ReferIt. Since ReferIt is a relative small dataset, we use a slightly smaller model which contains 3 cross attention layers in the query decoder. The results are shown in Table 3. Our model is able to perform better, by a large margin, than even the latest one-stage methods. We also observe a consistent boost brought by pretraining. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            608
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Qualitative Analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            638,
+            352,
+            654
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2, we show our qualitative comparison with previous state-of-the-art multi-task model – MCN [36]. The first two rows of Figure 2(a) show failure cases of MCN that can be better handled by our model. We observe that MCN appears to fail because it neglects some attributes in referring expression (e.g., \"yellow drink\" and \"blue striped shirt\"), while our model is able to better model the query and pay attention to object attributes. In the last row, we shows several failure cases of our model. For the first case, the query requires the model to have the ability to recognize number $\" 4 4 \"$ . For the second and third case, there is visual ambiguity to identify the nearest glass to the bowl or to determine which bear(brown or white) has the longest leg. ",
+        "bbox": [
+            173,
+            669,
+            826,
+            781
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 2(b), we show qualitative comparison in terms of referred segmentation mask. Compared to MCN, our model is able to output more detailed object shape and finer outlines. Moreover, our model shows the ability to handle shadows (e.g., the right bottom of the donut) and occlusions (e.g., the man occluded by another man’s arm) and predict smoother segmentation mask. We also give a result on a challenging case in the last row, where the texture boundary of the two giraffe is hard to distinguish. Despite imperfections, our model is still able to focus on the giraffe’s head in the foreground and performs much better than MCN. Part of our model’s ability to generate fine-grained mask can be explained by better localization ability brought by the REC task, in which case the RES head can focus on tuning the shape and boundary of the mask. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/62b5dbc5a955b227a6187f9be9633628854e5042bfc8f0b7374e39cf046f79d9.jpg",
+        "table_caption": [
+            "Table 4: Ablation studies. Table on the top ablates our multi-task and pretraining schehme on $\\operatorname { R e f C O C O } / + / \\mathrm { g }$ validation set. Table on the bottom ablates on core components of our model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>REC</td><td>RES Pretrain</td><td>REC Acc↑</td><td>RESMiou↑</td><td>IE</td></tr><tr><td>√</td><td>√</td><td>81.08 /70.02/68.15</td><td>66.03/58.39/54.61 =</td><td>23.52%</td></tr><tr><td>√</td><td>√</td><td>81.82 / 71.13 /69.32</td><td>69.94 / 60.90 / 57.69</td><td>4.73%</td></tr><tr><td>√</td><td>√</td><td>85.01/75.46/77.96</td><td>=</td><td></td></tr><tr><td>√</td><td>√ √</td><td>85.43 / 76.40 / 78.43</td><td>73.61 / 65.30 / 65.70</td><td>4.48%</td></tr></table>",
+        "bbox": [
+            272,
+            123,
+            725,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/e38a4a08de5d04aa5bdeaeb4f9cfc37b461ee0174c095a29856c670714270bce.jpg",
+        "table_caption": [
+            "Table 5: Results on RefCOCO $^ +$ Dataset with Different Input Resolutions. Our methods correspond to the RN50 model without pretraining. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Flickr30k</td></tr><tr><td rowspan=1 colspan=1>Model component-w/o Query Decoder-w/o Context Encoder</td><td rowspan=1 colspan=1>49.3873.68</td></tr><tr><td rowspan=1 colspan=1>Query Encoder-w/o Context&amp;Phrase Feature-w/o Context Feature-w/o Phrase Feature</td><td rowspan=1 colspan=1>42.0576.6477.02</td></tr><tr><td rowspan=1 colspan=1>Full model</td><td rowspan=1 colspan=1>78.13</td></tr></table>",
+        "bbox": [
+            370,
+            198,
+            625,
+            304
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0ef955392457586b7b877d1bc31b2791dfcab262386f5c6b8f7d22096d7eb881.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td rowspan=\"2\">Resolution</td><td colspan=\"3\">REC(prec@0.5)</td><td colspan=\"3\">RES(MIoU)</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>val</td><td>testA</td><td>testB</td></tr><tr><td>FAOA [51]</td><td>256× 256</td><td>56.81</td><td>60.23</td><td>49.60</td><td>-</td><td>-</td><td>-</td></tr><tr><td>ReSC-Large [52]</td><td>256× 256</td><td>63.59</td><td>68.36</td><td>56.81</td><td>-</td><td>-</td><td>1</td></tr><tr><td>CMPC[21]</td><td>320×320</td><td>1</td><td>-</td><td>1</td><td>49.56</td><td>53.44</td><td>43.23</td></tr><tr><td>LTS [22]</td><td>416× 416</td><td>-</td><td>=</td><td>=</td><td>54.21</td><td>58.32</td><td>48.02</td></tr><tr><td>MCN [36]</td><td>416× 416</td><td>67.16</td><td>72.86</td><td>57.31</td><td>50.62</td><td>54.99</td><td>44.69</td></tr><tr><td>Ours</td><td>256× 256</td><td>70.05</td><td>73.29</td><td>61.48</td><td>58.26</td><td>61.09</td><td>52.20</td></tr><tr><td>Ours</td><td>320×320</td><td>70.03</td><td>73.23</td><td>61.52</td><td>58.42</td><td>61.48</td><td>52.34</td></tr><tr><td>Ours</td><td>416× 416</td><td>71.50</td><td>75.87</td><td>61.71</td><td>61.00</td><td>64.48</td><td>52.44</td></tr><tr><td>Ours</td><td>640× 640</td><td>71.58</td><td>75.96</td><td>62.16</td><td>61.08</td><td>64.69</td><td>52.73</td></tr></table>",
+        "bbox": [
+            254,
+            344,
+            738,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            496,
+            328,
+            511
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first consider the importance of the multi-task setup in Table 4 (top). Results indicate that multi-task training consistently boosts both REC and RES performance on Refcoco $/ + / \\mathrm { g }$ datasets by a considerable margin. More specifically, we observe that REC loss helps the transformer to better locate the referred object and converge faster in early stages of training. At the same time, RES loss aids the model with more fine-grained information on the shape of the referred region, which helps to further enhance the accuracy. IE here is Inconsistency Error metric originally used in [36] to measure the prediction conflict between the REC and RES task. We can see that joint training of RES and REC greatly reduce the inconsistency between the two tasks. Note that our model also has a much lower multi-task inconsistency compared to MCN [36], with a corresponding IE score of $7 . 5 4 \\% ( - 4 0 \\% )$ . This shows that our model can do better collaborative learning. ",
+        "bbox": [
+            174,
+            525,
+            825,
+            662
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next, we validate the design of our network architecture. We report our scores on the Flickr30k test sets. In Table 4 (bottom), we ablate the model’s major components and features used to form the query. Without (w/o) context encoder indicates that we directly use learnable embedding to encode text; w/o Query Decoder means that we directly use the average pooled feature from the encoder to predict a single referred output. We can see that the context encoder plays an important role in providing good textual representation for further multi-modal fusion. Query encoders are also quite important without which we also observe a big performance drop. For the ablation on query features, we observe that both context feature and phrase features are crucial without which the performance will decrease considerably. The table also showed that the network will not work without guidance of both context and phrase features since we cannot establish a correspondence between multiple queries and outputs in such a case. ",
+        "bbox": [
+            173,
+            670,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In RES and REC tasks, the size of input image is a matter of trade off between performance and speed, which is largely effected by the network architecture. Despite that our model is designed to be able to process $6 4 0 \\times 6 4 0$ images at real time speed, we also test our model at different input resolution for reference, as showed in Table 5. Note that for resolution 256 and 320, we adjust strides in the final stage of ResNet to keep the number of visual features sent into visual-lingual encoder roughly the same. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/58ec28f4d7afef6e00fce8a5ad66983ca0d90677dabd3a4a9fc9cdfc16a77265.jpg",
+        "table_caption": [
+            "Table 6: Comparison with Concurrent Work. Performance on RefCOCO/RefCOCO $\\left| + \\right.$ /RefCOCOg datasets [55]. Ours∗ denotes that pretraining is used. All methods use ResNet101 image backbone. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Models</td><td rowspan=\"2\">Visual Features</td><td rowspan=\"2\">Pretrain Images</td><td rowspan=\"2\">Multi- task</td><td colspan=\"3\">RefCOCO</td><td colspan=\"3\">RefCOCO+</td><td rowspan=\"2\">RefC0COg</td></tr><tr><td>val</td><td>testA</td><td>testB</td><td>testA</td><td>testB</td><td>val-u</td></tr><tr><td>One-stage:</td><td></td><td></td><td></td><td></td><td></td><td></td><td>val</td><td></td><td></td><td></td><td>test-u</td></tr><tr><td>VGTR [10]</td><td>Bi-LSTM</td><td>None</td><td>×</td><td>79.20</td><td>82.32</td><td>73.78</td><td>63.91</td><td>70.09</td><td>56.51</td><td>65.73</td><td>67.23</td></tr><tr><td>TransVG [7]</td><td>BERT</td><td>None</td><td>×</td><td>81.02</td><td>82.72</td><td>78.35</td><td>64.82</td><td>70.70</td><td>56.94</td><td>68.67</td><td>67.73</td></tr><tr><td>Ours</td><td>BERT</td><td>None</td><td>√</td><td>82.23</td><td>85.59</td><td>76.57</td><td>71.58</td><td>75.96</td><td>62.16</td><td>69.41</td><td>69.40</td></tr><tr><td>Pretrained:</td><td></td><td></td><td>√</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>MDETR [23] Ours*</td><td>RoBERTa BERT</td><td>200k 100k</td><td>√</td><td>86.75 85.65</td><td>89.58 88.73</td><td>81.41 81.16</td><td>79.52 77.55</td><td>84.09 82.26</td><td>70.62 68.99</td><td>81.64 79.25</td><td>80.89 80.01</td></tr></table>",
+        "bbox": [
+            191,
+            125,
+            805,
+            227
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6 Comparison with Contemporaneous Work ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            238,
+            508,
+            253
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Concurrent and independent to us, very recently, there are some closely related works that use transformers for visual referring tasks [7, 10, 23]. We will briefly discuss some of the differences. ",
+        "bbox": [
+            174,
+            263,
+            821,
+            292
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To begin, [7, 10] focus on REC, while our approach is formulated in multi-task setting and solves both REC and RES tasks simultaneously. In addition, our model is faster and is capable of grounding multiple contextualized phrases, while [7, 10] follow previous one-stage approaches and are only able to infer a single expression at a time; leading, in our case, to more accurate results. MDETR [23] leverages contrastive loss and soft token loss to help better match bounding boxes to phrases. In contrast, our method adopts a simple and straightforward method to pre-match bounding boxes to phrases using a one-to-one matching; this leads to simpler learning objective. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            396
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We provide quantitative comparison on REC task with these approaches, based on their reported numbers in Table 6. Compared to [7, 10], our model performs substantially better in all, with an exception of RefCOCO testB (where [7] is marginally better), datasets and splits. The biggest improvements can be seen on $\\operatorname { R e f C O C O + }$ , where our model is $1 0 . 4 \\%$ better (or 6.76 points better), than the closest concurrent work of [7], on the Val split; similar sizable improvements are illustrated on other splits, e.g., $9 . 2 \\%$ on $\\operatorname { R e f C O C O + }$ testB. In addition, our approach is considerably faster in runtime, since our model is able to handle multiple queries simultaneously (unlike [7, 10]). Compared to [23], in a pretrained model setting, we see that our model performs similarly on RefCOCO and marginally worse on $\\operatorname { R e f C O C O + }$ and $\\operatorname { R e f C O C O g }$ . This difference can perhaps be attributed to two factors: (1) larger pretrain dataset and longer triaining schedule. (As reported in [23], MDETR takes 224 GPU days to pretrain, while the pretraining for our model is roughly 28 GPU days) (2) using more sophisticated language model (RoBERTa for [23] vs. BERT for us). Limited experiments in Supplemental Material show that indeed, the use of RoBERTa leads to certain improvements. In addition, we setup our method in multi-task setting to solve RES and REC task at the same time, so our formulation while perhaps marginally inferior on REC is more general overall. ",
+        "bbox": [
+            174,
+            401,
+            825,
+            609
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions and Future Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            459,
+            638
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present Referring Transformer, a one-step approach to referring expression comprehension (REC) and segmentation (RES). We jointly train our model for RES and REC tasks while enabling contextualized multi-expression references. Our models outperform state-of-the-art by a large margin on five / three datasets for REC / RES respectively, while achieving real-time runtime. ",
+        "bbox": [
+            174,
+            646,
+            825,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One limitation for our model is that we follow the setup in previous works [51, 52] and assume that each expression refers to only one region. In the future, we plan to explore learning to predict multiple regions for each referring entity if necessary. Large-scale multi-task pretraining has been demonstrated to be very effective for ViLBEERT and other similar architectures; this is complementary to our focus in this paper, and we expect such strategies to further improve the performance. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            779
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            583,
+            814
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This work was funded, in part, by the Vector Institute for AI, Canada CIFAR AI Chair, NSERC CRC, NSERC Discovery and Discovery Accelerator Grants. Resources used in preparing this research were provided, in part, by the Province of Ontario, the Government of Canada through CIFAR, and companies sponsoring the Vector Institute www.vectorinstitute.ai/#partners. Additional hardware support was provided by John R. Evans Leaders Fund CFI grant and Compute Canada under the Resource Allocation Competition award. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n[1] M. Bajaj, L. Wang, and L. Sigal. G3raphground: Graph-based language grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4281–4290, 2019.   \n[2] N. Carion, F. Massa, G. Synnaeve, N. Usunier, A. Kirillov, and S. Zagoruyko. End-to-end object detection with transformers. In European Conference on Computer Vision (ECCV), pages 213–229, 2020.   \n[3] K. Chen, R. Kovvuri, and R. Nevatia. Query-guided regression network with context policy for phrase grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 824–832, 2017.   \n[4] X. Chen, L. Ma, J. Chen, Z. Jie, W. Liu, and J. Luo. Real-time referring expression comprehension by single-stage grounding network. arXiv preprint arXiv:1812.03426, 2018.   \n[5] Y.-C. Chen, L. Li, L. Yu, A. El Kholy, F. Ahmed, Z. Gan, Y. Cheng, and J. Liu. Uniter: Universal image-text representation learning. In European Conference on Computer Vision (ECCV), pages 104–120, 2020.   \n[6] Y. W. Chen, Y. H. Tsai, T. Wang, Y. Y. Lin, and M. H. Yang. Referring expression object segmentation with caption-aware consistency. In Proceedings of the British Machine Vision Conference (BMVC), 2019.   \n[7] J. Deng, Z. Yang, T. Chen, W. Zhou, and H. Li. TransVG: End-to-end visual grounding with transformers. arXiv preprint arXiv:2104.08541, 2021.   \n[8] J. Devlin, M.-W. Chang, K. Lee, and K. Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. In Proceedings of the 2019 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long and Short Papers), pages 4171–4186, 2019.   \n[9] P. Dogan, L. Sigal, and M. Gross. Neural sequential phrase grounding (seqground). In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 4175–4184, 2019.   \n[10] Y. Du, Z. Fu, Q. Liu, and Y. Wang. Visual grounding with transformers. arXiv preprint arXiv:2105.04281, 2021.   \n[11] K. Duan, S. Bai, L. Xie, H. Qi, Q. Huang, and Q. Tian. Centernet: Keypoint triplets for object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 6569–6578, 2019.   \n[12] Z. Gan, Y.-C. Chen, L. Li, C. Zhu, Y. Cheng, and J. Liu. Large-scale adversarial training for vision-andlanguage representation learning. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), 2020.   \n[13] P. Gao, M. Zheng, X. Wang, J. Dai, and H. Li. Fast convergence of detr with spatially modulated co-attention. arXiv preprint arXiv:2101.07448, 2021.   \n[14] X. Glorot and Y. Bengio. Understanding the difficulty of training deep feedforward neural networks. In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, pages 249–256, 2010.   \n[15] K. He, X. Zhang, S. Ren, and J. Sun. Deep residual learning for image recognition. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770–778, 2016.   \n[16] K. He, G. Gkioxari, P. Dollár, and R. Girshick. Mask r-cnn. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2961–2969, 2017.   \n[17] R. Hong, D. Liu, X. Mo, X. He, and H. Zhang. Learning to compose and reason with language tree structures for visual grounding. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 2019.   \n[18] R. Hu, M. Rohrbach, and T. Darrell. Segmentation from natural language expressions. In European Conference on Computer Vision (ECCV), pages 108–124, 2016.   \n[19] R. Hu, M. Rohrbach, J. Andreas, T. Darrell, and K. Saenko. Modeling relationships in referential expressions with compositional modular networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1115–1124, 2017.   \n[20] Z. Hu, G. Feng, J. Sun, L. Zhang, and H. Lu. Bi-directional relationship inferring network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[21] S. Huang, T. Hui, S. Liu, G. Li, Y. Wei, J. Han, L. Liu, and B. Li. Referring image segmentation via cross-modal progressive comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[22] Y. Jing, T. Kong, W. Wang, L. Wang, L. Li, and T. Tan. Locate then segment: A strong pipeline for referring image segmentation. arXiv preprint arXiv:2103.16284, 2021.   \n[23] A. Kamath, M. Singh, Y. LeCun, I. Misra, G. Synnaeve, and N. Carion. MDETR–modulated detection for end-to-end multi-modal understanding. arXiv preprint arXiv:2104.12763, 2021.   \n[24] S. Kazemzadeh, V. Ordonez, M. Matten, and T. Berg. Referitgame: Referring to objects in photographs of natural scenes. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 787–798, 2014.   \n[25] R. Krishna, Y. Zhu, O. Groth, J. Johnson, K. Hata, J. Kravitz, S. Chen, Y. Kalantidis, L.-J. Li, D. A. Shamma, et al. Visual genome: Connecting language and vision using crowdsourced dense image annotations. International Journal of Computer Vision (IJCV), 123(1):32–73, 2017.   \n[26] Y. Liao, S. Liu, G. Li, F. Wang, Y. Chen, C. Qian, and B. Li. A real-time cross-modality correlation filtering method for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2020.   \n[27] T.-Y. Lin, M. Maire, S. Belongie, J. Hays, P. Perona, D. Ramanan, P. Dollár, and C. L. Zitnick. Microsoft coco: Common objects in context. In European Conference on Computer Vision (ECCV), pages 740–755, 2014.   \n[28] T.-Y. Lin, P. Goyal, R. Girshick, K. He, and P. Dollár. Focal loss for dense object detection. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2980–2988, 2017.   \n[29] D. Liu, H. Zhang, F. Wu, and Z.-J. Zha. Learning to assemble neural module tree networks for visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4673–4682, 2019.   \n[30] X. Liu, Z. Wang, J. Shao, X. Wang, and H. Li. Improving referring expression grounding with crossmodal attention-guided erasing. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1950–1959, 2019.   \n[31] J. Long, E. Shelhamer, and T. Darrell. Fully convolutional networks for semantic segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 3431– 3440, 2015.   \n[32] I. Loshchilov and F. Hutter. Decoupled weight decay regularization. In International Conference on Learning Representations (ICLR), 2019.   \n[33] J. Lu, D. Batra, D. Parikh, and S. Lee. ViLBERT: Pretraining task-agnostic visiolinguistic representations for vision-and-language tasks. In Proceedings of the International Conference on Neural Information Processing Systems (NeurIPS), pages 13–23, 2019.   \n[34] J. Lu, V. Goswami, M. Rohrbach, D. Parikh, and S. Lee. 12-in-1: Multi-task vision and language representation learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 10437–10446, 2020.   \n[35] G. Luo, Y. Zhou, R. Ji, X. Sun, J. Su, C.-W. Lin, and Q. Tian. Cascade grouped attention network for referring expression segmentation. In ACM International Conference on Multimedia, 2020.   \n[36] G. Luo, Y. Zhou, X. Sun, L. Cao, C. Wu, C. Deng, and R. Ji. Multi-task collaborative network for joint referring expression comprehension and segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2020.   \n[37] J. Mao, J. Huang, A. Toshev, O. Camburu, A. L. Yuille, and K. Murphy. Generation and comprehension of unambiguous object descriptions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 11–20, 2016.   \n[38] E. Margffoy-Tuay, J. C. Pérez, E. Botero, and P. Arbeláez. Dynamic multimodal instance segmentation guided by natural language queries. In European Conference on Computer Vision (ECCV), 2018.   \n[39] F. Milletari, N. Navab, and S.-A. Ahmadi. V-net: Fully convolutional neural networks for volumetric medical image segmentation. In International Conference on 3D Vision (3DV), pages 565–571, 2016.   \n[40] V. K. Nagaraja, V. I. Morariu, and L. S. Davis. Modeling context between objects for referring expression understanding. In European Conference on Computer Vision (ECCV), pages 792–807, 2016.   \n[41] B. A. Plummer, L. Wang, C. M. Cervantes, J. C. Caicedo, J. Hockenmaier, and S. Lazebnik. Flickr30k entities: Collecting region-to-phrase correspondences for richer image-to-sentence models. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 2641–2649, 2015.   \n[42] B. A. Plummer, P. Kordas, M. H. Kiapour, S. Zheng, R. Piramuthu, and S. Lazebnik. Conditional image-text embedding networks. In European Conference on Computer Vision (ECCV), pages 249–264, 2018.   \n[43] J. Redmon and A. Farhadi. Yolov3: An incremental improvement. arXiv preprint arXiv:1804.02767, 2018.   \n[44] S. Ren, K. He, R. Girshick, and J. Sun. Faster r-cnn: Towards real-time object detection with region proposal networks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 39(6): 1137–1149, 2017.   \n[45] H. Rezatofighi, N. Tsoi, J. Gwak, A. Sadeghian, I. Reid, and S. Savarese. Generalized intersection over union: A metric and a loss for bounding box regression. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 658–666, 2019.   \n[46] A. Sadhu, K. Chen, and R. Nevatia. Zero-shot grounding of objects from natural language queries. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4694–4703, 2019.   \n[47] H. Tan and M. Bansal. Lxmert: Learning cross-modality encoder representations from transformers. Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), 2019.   \n[48] L. Wang, Y. Li, J. Huang, and S. Lazebnik. Learning two-branch neural networks for image-text matching tasks. IEEE Transactions on Pattern Analysis and Machine Intelligence (TPAMI), 41(2):394–407, 2018.   \n[49] T. Wolf, L. Debut, V. Sanh, J. Chaumond, C. Delangue, A. Moi, P. Cistac, T. Rault, R. Louf, M. Funtowicz, J. Davison, S. Shleifer, P. von Platen, C. Ma, Y. Jernite, J. Plu, C. Xu, T. L. Scao, S. Gugger, M. Drame, Q. Lhoest, and A. M. Rush. Transformers: State-of-the-art natural language processing. In Proceedings of the Conference on Empirical Methods in Natural Language Processing (EMNLP), pages 38–45, 2020.   \n[50] S. Yang, G. Li, and Y. Yu. Propagating over phrase relations for one-stage visual grounding. In European Conference on Computer Vision, pages 589–605. Springer, 2020.   \n[51] Z. Yang, B. Gong, L. Wang, W. Huang, D. Yu, and J. Luo. A fast and accurate one-stage approach to visual grounding. In Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), pages 4683–4693, 2019.   \n[52] Z. Yang, T. Chen, L. Wang, and J. Luo. Improving one-stage visual grounding by recursive sub-query construction. In European Conference on Computer Vision (ECCV), 2020.   \n[53] L. Ye, M. Rochan, Z. Liu, and Y. Wang. Cross-modal self-attention network for referring image segmentation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), 2019.   \n[54] F. Yu, J. Tang, W. Yin, Y. Sun, H. Tian, H. Wu, and H. Wang. Ernie-vil: Knowledge enhanced visionlanguage representations through scene graph. arXiv preprint arXiv:2006.16934, 2020.   \n[55] L. Yu, P. Poirson, S. Yang, A. C. Berg, and T. L. Berg. Modeling context in referring expressions. In European Conference on Computer Vision (ECCV), pages 69–85, 2016.   \n[56] L. Yu, Z. Lin, X. Shen, J. Yang, X. Lu, M. Bansal, and T. L. Berg. Mattnet: Modular attention network for referring expression comprehension. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 1307–1315, 2018.   \n[57] Z. Yu, J. Yu, C. Xiang, Z. Zhao, Q. Tian, and D. Tao. Rethinking diversified and discriminative proposal generation for visual grounding. International Joint Conference on Artificial Intelligence (IJCAI), 2018.   \n[58] X. Zhu, W. Su, L. Lu, B. Li, X. Wang, and J. Dai. Deformable detr: Deformable transformers for end-to-end object detection. In International Conference on Learning Representations (ICLR), 2021. ",
+        "bbox": [
+            171,
+            74,
+            828,
+            916
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            69,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            857
+        ],
+        "page_idx": 12
+    }
+]

parse/train/rkA1f3NpZ/rkA1f3NpZ.md

@@ -0,0 +1,209 @@
+# ENSEMBLE METHODS AS A DEFENSE TO ADVERSARIAL PERTURBATIONS AGAINST DEEP NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Deep learning has become the state of the art approach in many machine learning problems such as classification. It has recently been shown that deep learning is highly vulnerable to adversarial perturbations. Taking the camera systems of self-driving cars as an example, small adversarial perturbations can cause the system to make errors in important tasks, such as classifying traffic signs or detecting pedestrians. Hence, in order to use deep learning without safety concerns a proper defense strategy is required. We propose to use ensemble methods as a defense strategy against adversarial perturbations. We find that an attack leading one model to misclassify does not imply the same for other networks performing the same task. This makes ensemble methods an attractive defense strategy against adversarial attacks. We empirically show for the MNIST and the CIFAR-10 data sets that ensemble methods not only improve the accuracy of neural networks on test data but also increase their robustness against adversarial perturbations.
+
+# 1 INTRODUCTION
+
+In recent years, deep neural networks (DNNs) led to significant improvements in many areas ranging from computer vision (Krizhevsky et al., 2012; LeCun et al., 2015) to speech recognition (Hinton et al., 2012; Dahl et al., 2012). Some applications that can be solved with DNNs are sensitive from the security perspective, for example camera systems of self driving cars for detecting traffic signs or pedestrians (Papernot et al., 2016b; Sermanet & LeCun, 2011). Recently, it has been shown that DNNs can be highly vulnerable to adversaries (Szegedy et al., 2013; Goodfellow et al., 2014; Papernot et al., 2016a;b). The adversary produces some kind of noise on the input of the system to mislead its output behavior, producing undesirable outcomes or misclassification. Adversarial perturbations are carefully chosen in order to be hard, if not impossible, to be detected by the human eye (see figure 1). Attacks occur after the training of the DNN is completed. Furthermore, it has been shown that the exact structure of the DNN does not need to be known in order to mislead the system as one can send inputs to the unknown system in order to record its outputs to train a new DNN that imitates its behavior (Papernot et al., 2016b). Hence, in this manuscript it is assumed that the DNN and all its parameters are fully known to the adversary.
+
+There are many methods on how to attack neural networks appearing in the literature. Some of the most well-known ones are the Fast Gradient Sign Method (Goodfellow et al., 2014) and its iterative extension (Kurakin et al., 2016), DeepFool (Moosavi-Dezfooli et al., 2016), Jacobian-Based Saliency Map Attack (Papernot et al., 2016c), and the L-BFGS Attack (Szegedy et al., 2013). This shows the need of building neural networks that are themselves robust against any kind of adversarial perturbations.
+
+Novel methods on defending against adversarial attacks are appearing more and more frequently in the literature. Some of those defense methods are to train the network with different kinds of adversarially perturbated training data (Goodfellow et al., 2014; Papernot et al., 2016c), the use of distillation to reduce the effectiveness of the perturbation (Papernot et al., 2016d) or to apply denoising autoencoders to preprocess the data used by the DNN (Gu & Rigazio, 2014). It also has been noted that adversarial attacks can be detected (Metzen et al., 2017; Feinman et al., 2017), but these detection systems are again vulnerable to adversarial attacks. To our knowledge, there is no method that can reliably defend or detect all kinds of adversarial attacks.
+
+![](images/9127e1674e35706ff747ebc18841ec99f6de0fdc31a8d2546cb04ce3a3c7f351.jpg)  
+Figure 1: The first line shows original and correctly classified MNIST test data images. In the second line are the corresponding adversarial BIM attacks on a single classifier ( $\epsilon = 0 . 2$ , $\alpha = 0 . 0 2 5$ , $n = 8$ ) which predicts (from left to right): 6, 8, 1, 5, 9, 3, 0, 2, 2, and 4. Analogously, the third line corresponds to correctly predicted examples of the CIFAR-10 test data set. In the bottom line are the corresponding adversarial BIM attacks on a single classifier $\epsilon = 0 . 0 2$ , $\alpha = 0 . 0 0 2 5$ , $n = 8$ ) which predicts (from left to right): deer, cat, deer, ship, bird, deer, deer, frog, automobile, and automobile.
+
+In this manuscript, ensemble methods are used to obtain a classification system that is more robust against adversarial perturbations. The term ensemble method refers to constructing a set of classifiers used to classify new data points by the weighted or unweighted average of their predictions. Many ensemble methods have been introduced in the literature such as Bayesian averaging, Bagging (Breiman, 1996) and boosting (Dietterich et al., 2000). These methods frequently win machine learning competitions, for example the Netflix prize (Koren, 2009). Initial results on using ensembles of classifiers in adversarial context can be found in (Abbasi & Gagne, 2017; He et al., 2017). ´ However, to the best of our knowledge this is the first manuscript that empirically evaluates the robustness of ensemble methods to adversarial perturbations.
+
+One advantage of using ensemble methods as defense against adversarial perturbations is that they also increase the accuracy on unperturbed test data. This is not the case in general for other defense methods (see Table 4). However, in most applications a perturbated input can be considered as exception. Hence, it is desirable to obtain a state of the art result on unperturbed test data while making the model more robust against adversarial attacks. Another advantage is that ensemble methods can easily be combined with other defense mechanisms to improve the robustness against adversarial perturbations further (see Table 4). However, the advantages come at a cost of an increase of computational complexity and memory requirements which are proportional to the number of classifiers in the ensemble.
+
+This paper is organized as follows: In section 2, some methods for producing adversarial perturbations are briefly introduced. Section 3 describes the defense strategy proposed in this manuscript. In section 4, the previous methods are tested on the MNIST and CIFAR-10 data sets and are compared to other defense strategies appearing in the literature. Finally, in section 5 the conclusions are presented.
+
+# 2 ADVERSARIAL ATTACK
+
+In this section, two methods for producing adversarial attacks shall be briefly described. In the following, let $\theta$ be the parameters of a model, $x$ the input of the model and $y$ the output value associated with the input value $x$ . Further, let $J ( \theta , x , y )$ be the cost function used to train the DNN.
+
+# FAST GRADIENT SIGN METHOD
+
+The fast gradient sign method (FGSM) by Goodfellow et al. (2014) simply adds some small perturbations of size $\epsilon > 0$ to the input $x$ ,
+
+$$
+x _ { \mathrm { F G S M } } = x + \epsilon \mathrm { s i g n } [ \nabla _ { x } J ( \theta , x , y ) ] ,
+$$
+
+where the gradient $\nabla _ { x } J ( \theta , x , y )$ can be computed using backpropagation. This relatively cheap and simple adversarial perturbation performs well on many DNNs. It is believed that this behavior is due to linear elements such as ReLUs or maxout networks in the DNNs (Goodfellow et al., 2014).
+
+# BASIC ITERATIVE METHOD
+
+The basic iterative method (BIM) by Kurakin et al. (2016) is an iterative extension of FGSM. The idea is to choose $\epsilon \geq \alpha > 0$ and then apply some perturbations similar to FGSM to the input $x$ and repeat the process $n$ times:
+
+$$
+\begin{array} { r l } & { x _ { 0 } = x , } \\ & { x _ { i } = \mathrm { c l i p } _ { x , \epsilon } \left( x _ { i - 1 } + \alpha \mathrm { s i g n } [ \nabla _ { x _ { i - 1 } } J ( \theta , x _ { i - 1 } , y ) ] \right) , } \\ & { x _ { \mathrm { B I M } } = x _ { n } . } \end{array}
+$$
+
+Here, $\mathrm { c l i p } _ { x , \epsilon } ( \cdot )$ refers to clipping the values of the adversarial sample so that they remain within an $\epsilon$ -neighborhood of $x$ .
+
+# 3 ENSEMBLE METHODS
+
+Ensemble methods are widely used to improve classifiers in supervised learning (Dietterich et al., 2000). The idea is to construct a set of classifiers that is used to classify a new data point by the weighted or unweighted average of their predictions. In order for an ensemble to outperform a single classifier it must be both accurate and diverse (Hansen & Salamon, 1990). A classifier is said to be accurate if it is better than random guessing, and a set of classifiers is said to be diverse if different classifiers make different errors on new data points.
+
+As expected, when performing adversarial perturbations on new data points different classifiers perform quite differently on these points. Hence, we conclude that diversity on adversarial perturbations is given. Furthermore, for adversarial perturbations with small $\epsilon > 0$ , the vast majority of classifiers was accurate. In other words, for any small $\epsilon > 0$ , we could not find an adversarial attack that would turn the majority of classifiers into non-accurate classifiers.
+
+In section 4, the following ensemble methods are used. Note that random initialization of the model parameters is used in all methods.
+
+(i) The first method is to train multiple classifiers with the same network architecture but with random initial weights. This results in quite diverse classifiers with different final weights (Kolen & Pollack, 1991).   
+(ii) The second method is to train multiple classifiers with different but similar network architectures to ensure obtaining a set of even more diverse classifiers. That is, extra filters are used in one classifier or an extra convolution layer is added to another classifier.   
+(iii) Third, Bagging (Breiman, 1996) is used on the training data. The term Bagging is derived from bootstrap aggregation and it consists of drawing $m$ samples with replacement from the training data set of $m$ data points. Each of these new data sets is called a bootstrap replicate. At average each of them contains $6 3 . 2 \%$ of the training data, where many data points are repeated in the bootstrap replicates. A different bootstrap replicate is used as training data for each classifier in the ensemble.   
+(iv) The last method is to add some small Gaussian noise to the training data so that all classifiers are trained on similar but different training sets. Note that adding Gaussian noise to the training data also makes each classifier somewhat more robust against adversarial perturbations.
+
+Once an ensemble of classifiers is trained, it predicts by letting each classifier vote for a label. More specifically, the predicted value is chosen to be the label that maximizes the average of the output probabilities from the classifiers in the ensemble.
+
+In order to attack a network with the methods from section 2 the gradient $\nabla _ { x } J ( \theta , x , y )$ must be computed. However, obtaining the gradient for an ensemble requires to calculate the gradient of each of its classifiers. Nevertheless, the following two methods are used to estimate the gradient of an ensemble, which are referred to as Grad. 1 and Grad. 2 for the rest of this manuscript:
+
+Grad. 1 Use $\nabla _ { x } J ( \theta _ { i } , x , y )$ of the $i$ -th classifier. This is clearly not the correct gradient for an ensemble. But the question is whether an attack with this gradient can already mislead all classifiers in the ensemble in a similar manner.   
+Grad. 2 Compute the average of the gradients $\begin{array} { r } { \frac { 1 } { n } \sum _ { i } \nabla _ { x } J ( \theta _ { i } , x , y ) \ } \end{array}$ from all classifiers in the ensemble.
+
+A comparison of the effects of these two gradients for attacking ensembles can be found in section 4.
+
+# 4 EXPERIMENTS
+
+In this section the ensemble methods from section 3 are empirically evaluated on the MNIST (LeCun et al., 1998) and the CIFAR-10 (Krizhevsky & Hinton, 2009) data sets which are scaled to the unit interval. All experiments have been performed on ensembles of 10 classifiers. Note that this choice has been done for comparability. That is, in some cases the best performance was already reached with ensembles of less classifiers while in others more classifiers might improve the results.
+
+A summary of the experimental results can be found in Table 2 and the corresponding visualization in Figure 2. A comparison of ensembles with other defense methods and a combination of those with ensembles can be found in Table 4. In the following all FGSM perturbations are done with $\epsilon = 0 . 3$ on MNIST and with $\epsilon = 0 . 0 3$ on CIFAR-10. Furthermore, all BIM perturbations are done with $\epsilon = 0 . 2$ , $\alpha = 0 . 0 2 5$ and $n = 8$ iterations on MNIST and with $\epsilon = 0 . 0 2$ , $\alpha = 0 . 0 0 2 5$ and $n = 8$ on CIFAR-10. The abbreviations in Table 2 and in Figure 2 shall be interpreted in the following way: Rand. Ini. refers to random initialization of the weights of the neural network, Mix. Mod. means that the network architecture was slightly different for each classifier in an ensemble, Bagging refers to classifiers trained on bootstrap replicates of the training data, and Gauss noise implies that small Gaussian noise has been added to the training data. Each ensemble is attacked with FGSM and BIM based on the gradients from Grad. 1 and Grad. 2. In Table 2, the term Single refers to evaluating a single classifier.
+
+# MNIST
+
+The MNIST data set consists of 60,000 training and 10,000 test data samples of black and white encoded handwritten digits. The objective is to classify these digits in the range from 0 to 9. A selection of images from the data set and some adversarial perturbations can be found in the top two rows of figure 1. In the experiments, the network architecture in Table 1 is used and it is trained with 10 epochs. All results from the experiments are summarized in Table 2.
+
+On unperturbed test data the classification accuracy is roughly $9 9 \%$ . The difference between single classifiers and ensembles is below one percent throughout. The ensembles slightly outperform the single classifiers in all cases.
+
+Table 1: MNIST Network Architecture   
+
+<table><tr><td>Layer Type</td><td>Parameters</td></tr><tr><td>Relu Convolutional</td><td>32 filters (3×3)</td></tr><tr><td>Relu Convolutional</td><td>32 filters (3×3)</td></tr><tr><td>Max Pooling</td><td>2×2</td></tr><tr><td>Relu Fully Connected</td><td>128 units</td></tr><tr><td>Dropout</td><td>0.5</td></tr><tr><td>Relu Fully Connected</td><td>10 units</td></tr><tr><td>Softmax</td><td>10 units</td></tr></table>
+
+Table 2: Experimental results on the MNIST and the CIFAR-10 data sets   
+MNIST Accuracy   
+
+<table><tr><td colspan="2">Test Data</td><td colspan="2">No Attack</td><td colspan="2">Grad. 1</td><td>Grad. 2</td></tr><tr><td>Type</td><td>Method</td><td>Single</td><td>Ensemble</td><td>Single</td><td>Ensemble</td><td>Ensemble</td></tr><tr><td rowspan="4">FGSM</td><td>Rand. Ini.</td><td>0.9912</td><td>0.9942</td><td>0.3791</td><td>0.6100</td><td>0.4517</td></tr><tr><td>Mix. Mod.</td><td>0.9918</td><td>0.9942</td><td>0.3522</td><td>0.5681</td><td>0.4609</td></tr><tr><td>Bagging</td><td>0.9900</td><td>0.9927</td><td>0.4045</td><td>0.6738</td><td>0.5716</td></tr><tr><td>Gauss Noise</td><td>0.9898</td><td>0.9920</td><td>0.5587</td><td>0.7816</td><td>0.7043</td></tr><tr><td rowspan="4">BIM</td><td>Rand. Ini.</td><td>0.9912</td><td>0.9942</td><td>0.0906</td><td>0.6518</td><td>0.8875</td></tr><tr><td>Mix.Mod.</td><td>0.9918</td><td>0.9942</td><td>0.0582</td><td>0.6656</td><td>0.9076</td></tr><tr><td>Bagging</td><td>0.9900</td><td>0.9927</td><td>0.1110</td><td>0.7068</td><td>0.9233</td></tr><tr><td>Gauss Noise</td><td>0.9898</td><td>0.9920</td><td>0.5429</td><td>0.9152</td><td>0.9768</td></tr></table>
+
+CIFAR-10 Accuracy   
+
+<table><tr><td colspan="2">Test Data</td><td colspan="2">No Attack</td><td colspan="2">Grad. 1</td><td>Grad. 2</td></tr><tr><td>Type</td><td>Method</td><td>Single</td><td>Ensemble</td><td>Single</td><td>Ensemble</td><td>Ensemble</td></tr><tr><td rowspan="4">FGSM</td><td>Rand. Ini.</td><td>0.7984</td><td>0.8448</td><td>0.1778</td><td>0.4538</td><td>0.3302</td></tr><tr><td>Mix. Mod.</td><td>0.7898</td><td>0.8400</td><td>0.1643</td><td>0.4339</td><td>0.3140</td></tr><tr><td>Bagging</td><td>0.7815</td><td>0.8415</td><td>0.1822</td><td>0.4788</td><td>0.3571</td></tr><tr><td>Gauss Noise</td><td>0.7160</td><td>0.7687</td><td>0.2966</td><td>0.6097</td><td>0.4707</td></tr><tr><td rowspan="4">BIM</td><td>Rand. Ini.</td><td>0.7984</td><td>0.8448</td><td>0.1192</td><td>0.5232</td><td>0.6826</td></tr><tr><td>Mix. Mod.</td><td>0.7898</td><td>0.8400</td><td>0.1139</td><td>0.5259</td><td>0.6768</td></tr><tr><td>Bagging</td><td>0.7815</td><td>0.8415</td><td>0.1280</td><td>0.5615</td><td>0.7166</td></tr><tr><td>Gauss Noise</td><td>0.7160</td><td>0.7687</td><td>0.3076</td><td>0.6735</td><td>0.7277</td></tr></table>
+
+This picture changes dramatically if the networks are attacked by one of the methods described in section 2. Using the FGSM attack with gradients from Grad. 1 on a single classifier, the classification rate drops down to a range of roughly $3 5 \% { - } 5 6 \%$ . The ensembles perform significantly better by producing an accuracy of $5 7 \% - 7 8 \%$ . Evaluating the same with gradients from Grad. 2 it turns out that ensemble methods still obtain an accuracy of $45 \% - 7 0 \%$ . The higher accuracy of Grad. 1 is expected since in contrast to Grad. 2 it computes the gradients with respect to just one classifier. Nevertheless, the ensembles outperform single classifiers in each case by approximately $7 \% - 2 2 \%$ .
+
+The decrease of the accuracy is even more extreme for single classifiers if the BIM method is used. Here, the accuracy can be as low as around $6 \%$ and only the classifiers trained with Gaussian noise significantly exceed the $10 \%$ . The accuracy of the ensemble methods against attacks using Grad. 1 is considerably higher with $6 5 \% { - } 9 2 \%$ . Furthermore, ensembles are even more robust against BIM attacks based on Grad. 2 with a correct classification rate of $89 \% - 9 8 \%$ . It is surprising that BIM attacks using Grad. 1 are more successful than those using Grad. 2, because Grad. 1 only attacks a single classifier in the ensemble. Concluding, the ensemble methods outperform single classifiers significantly by $3 7 \% 8 5 \%$ on BIM attacks.
+
+Focusing on the different defense strategies, we observe that using random initialization of the network weights as well as using several networks of similar architectures for an ensemble generally improves the robustness against adversarial attacks considerably in comparison with single classifiers. Bagging outperforms both of the previous methods on adversarial perturbations, but performs slightly worse on unperturbed test data. Using ensembles with small Gaussian noise on the training data results in the best defense mechanism against adversarial attacks. This may be due to the fact that using additive noise on the training data already makes every single classifier in the ensemble more robust against adversarial perturbations. On the down-side, adding Gaussian noise to the training data performs worst from all considered ensemble methods on test data. However, such an ensemble still performs better than all single classifiers on MNIST.
+
+![](images/d1c4ae0569cb52f4202724269f5dffd84f378a5db113a84d8cc0257b4219ef28.jpg)  
+Figure 2: Visual comparisons of the accuracies presented in Table 2. Compared are the MNIST (top row) and CIFAR-10 (bottom row) data sets on the FGSM (left column) and the BIM (right column) attacks. Grad. 1 Single refers to attacks based on Grad. 1 on single classifiers, Grad. 1 Ensemble refers to attacks based on Grad. 1 on ensembles, Grad. 2 Ensemble refers to attacks based on Grad. 2 on ensemble classifiers, No Attack Single refers to single classifier on unperturbed data, and finally No Attack Ensemble refers to ensemble classifiers on unperturbed data.
+
+# CIFAR-10
+
+The CIFAR-10 data set consists of 50,000 training and 10,000 test data samples of three-color component encoded images of ten mutually exclusive classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck. A selection of images from the data set and some adversarial perturbations can be found in the two bottom rows of figure 1. In all experiments the network architecture described in Table 3 is used and the networks are trained with 25 epochs.
+
+In general, the observations on the MNIST data set are confirmed by the experiments on CIFAR10. Since the latter data set is more demanding to classify, the overall classification rate is already lower in the attack-free case, where single classifiers reach an accuracy of roughly $7 2 \% - 8 0 \%$ , while ensembles show a higher accuracy of $7 7 \% - 8 4 \%$ . Note that there are network architectures in the literature that outperform our classifiers considerably on test data (Graham, 2014).
+
+The FGSM attacks on single classifiers using method Grad. 1 show a drop-down of the accuracy to $1 6 \% - 3 0 \%$ . In contrast, ensembles are significantly better reaching accuracies of $4 3 \% - 6 1 \%$ when attacked using Grad. 1 and $3 1 \% - 4 7 \%$ when attacked with Grad. 2.
+
+Table 3: CIFAR-10 Network Architecture   
+
+<table><tr><td>Layer Type</td><td>Parameters</td></tr><tr><td>Relu Convolutional Relu Convolutional Max Pooling Dropout</td><td>32 filters (3×3) 32 filters (3×3) 2×2 0.2</td></tr><tr><td>Relu Convolutional Relu Convolutional Max Pooling Dropout Relu Convolutional</td><td>64 filters (3×3) 64 filters (3×3) 2×2 0.3</td></tr><tr><td>Relu Convolutional</td><td>128 filters (3×3)</td></tr><tr><td></td><td>128 filters (3×3)</td></tr><tr><td>Max Pooling Dropout Relu Fully Connected Dropout Relu Fully Connected Softmax</td><td>2×2 0.4 512 units 0.5 10 units</td></tr></table>
+
+When using BIM attacks accuracies for single classifiers lie between $11 \%$ and $31 \%$ . Again, the ensemble methods outperform the single classifiers reaching accuracies of $5 2 \% - 6 7 \%$ when attacked using Grad. 1 and $6 8 \% - 7 3 \%$ when attacked with Grad. 2.
+
+The same observations as on the MNIST data set can be made on the CIFAR-10 data set. All ensemble methods outperform single classifiers when comparing their robustness against adversarial perturbations. FGSM attacks on an ensemble using Grad. 2 outperform those using Grad. 1, as expected. Similar to the MNIST experiments, when using BIM attacks, ensembles are surprisingly more robust against gradient attacks from Grad. 2 than against gradient attacks from Grad. 1. The reason for this might be that the gradient portion from different classifiers using Grad. 2 in the ensemble try to reach a different local maximum and block each other in the following iterations.
+
+As already observed on the MNIST data set, Bagging performs better than random initialization and than using similar but different network architectures. Again, adding small Gaussian noise on the training data performs best on adversarial perturbations but relatively poor on real test data on CIFAR-10.
+
+# COMPARISON WITH OTHER METHODS
+
+In this section, we compare the previous results with two of the most popular defense methods: adversarial training (Goodfellow et al., 2014; Papernot et al., 2016c) and defensive distillation (Papernot et al., 2016d). Furthermore, we show the positive effects of combining those methods with ensembles. For simplicity, we only consider the gradient Grad. 2 whenever an ensemble is attacked. The results are summarized in Table 4. Here, the content shall be interpreted in the following way: Bagging refers to ensembles trained with bagging, Adv. Train. to adversarial training, Def. Dist. to defensive distillation, the operator $^ +$ to combinations of the previous methods, bold text to the best performance of the first three methods, and the asterisk to the best method including combinations of defensive strategies.
+
+Adversarial training (AT) is a method that uses FGSM as regularizer of the original cost function:
+
+$$
+J _ { A T } ( \theta , x , y ) = \rho J ( \theta , x , y ) + ( 1 - \rho ) J ( \theta , x + \epsilon \operatorname { s i g n } ( \nabla _ { x } J ( \theta , x , y ) ) , y ) ,
+$$
+
+where $\rho \in [ 0 , 1 ]$ . This method iteratively increases the robustness against adversarial perturbations.   
+In our experiments, we use $\rho = { \textstyle { \frac { 1 } { 2 } } }$ as proposed in Goodfellow et al. (2014).
+
+Table 4: Accuracies of different defense mechanisms   
+
+<table><tr><td></td><td colspan="3">MNIST</td><td colspan="3">CIFAR-10</td></tr><tr><td>Methods</td><td>No Attack</td><td>FGSM</td><td>BIM</td><td>No Attack</td><td>FGSM</td><td>BIM</td></tr><tr><td>Bagging</td><td>0.9927*</td><td>0.5716</td><td>0.9233</td><td>0.8415*</td><td>0.3571</td><td>0.7166*</td></tr><tr><td>Adv.Train.</td><td>0.9902</td><td>0.3586</td><td>0.5420</td><td>0.7712</td><td>0.1778</td><td>0.3107</td></tr><tr><td>Def. Dist.</td><td>0.9840</td><td>0.0798</td><td>0.3829</td><td>0.7140</td><td>0.1828</td><td>0.3635</td></tr><tr><td>Bagging + Adv. Train.</td><td>0.9927*</td><td>0.8703*</td><td>0.9840*</td><td>0.8320</td><td>0.5010*</td><td>0.7017</td></tr><tr><td>Bagging + Def. Dist.</td><td>0.9875</td><td>0.0954</td><td>0.4514</td><td>0.7323</td><td>0.1839</td><td>0.4569</td></tr></table>
+
+In defensive distillation a teacher model $F$ is trained on a training data set $X$ . Then smoothed labels at temperature $T$ are computed by
+
+$$
+F ^ { T } ( X ) = \left[ \frac { \exp ( F _ { i } ( X ) / T ) } { \sum _ { i = 1 } ^ { N } \exp ( F _ { i } ( X ) / T ) } \right] _ { i \in \{ 1 , \ldots , N \} } ,
+$$
+
+where $F _ { i } ( X )$ refers to the probability of the $i$ -th out of $N$ possible classes. A distilled network is a network that is trained on the training data $X$ using the smoothed labels $F ^ { T } ( X )$ . In the following, we use $T = 1 0$ based on the experimental results in Papernot et al. (2016d).
+
+We found that single networks trained with adversarial training or defensive distillation have a lower accuracy than ensembles trained with bagging (see the top three rows in Table 4). This is not only the case on the considered attacked data but also on unperturbated test data. Combining ensembles with adversarial training can improve the robustness against adversarial perturbations further, while a combination with defensive distillation does not reveal the same tendency (see the two bottom rows in Table 4). We emphasize that already the standard ensemble method does not only outperform both adversarial training and defensive distillation throughout but also has the overall highest accuracy on unperturbated test data.
+
+# 5 CONCLUSION
+
+With the rise of deep learning as the state-of-the-art approach for many classification tasks, researchers noted that neural networks are highly vulnerable to adversarial perturbations. This is particularly problematic when neural networks are used in security sensitive applications such as autonomous driving. Hence, with the development of more efficient attack methods against neural networks it is desirable to obtain neural networks that are themselves robust against adversarial attacks.
+
+In this manuscript, it is shown that several ensemble methods such as random initialization or Bagging do not only increase the accuracy on the test data, but also make the classifiers considerably more robust against certain adversarial attacks. We consider ensemble methods as sole defense methods, but more robust classifiers can be obtained by combining ensemble methods with other defense mechanisms such as adversarial training. Although only having tested simple attack scenarios, it can be expected that ensemble methods may improve the robustness against other adversarial attacks.
+
+# REFERENCES
+
+Mahdieh Abbasi and Christian Gagne. Robustness to adversarial examples through an ensemble of ´ specialists. arXiv preprint arXiv:1702.06856, 2017.
+
+Leo Breiman. Bagging predictors. Machine learning, 24(2):123–140, 1996.
+
+George E Dahl, Dong Yu, Li Deng, and Alex Acero. Context-dependent pre-trained deep neural networks for large-vocabulary speech recognition. IEEE Transactions on audio, speech, and language processing, 20(1):30–42, 2012.
+
+Thomas G Dietterich et al. Ensemble methods in machine learning. Multiple classifier systems, 1857:1–15, 2000.
+
+Reuben Feinman, Ryan R Curtin, Saurabh Shintre, and Andrew B Gardner. Detecting adversarial samples from artifacts. arXiv preprint arXiv:1703.00410, 2017.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Benjamin Graham. Fractional max-pooling. arXiv preprint arXiv:1412.6071, 2014.
+
+Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014.
+
+Lars Kai Hansen and Peter Salamon. Neural network ensembles. IEEE transactions on pattern analysis and machine intelligence, 12(10):993–1001, 1990.
+
+Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+John F Kolen and Jordan B Pollack. Back propagation is sensitive to initial conditions. In Advances in neural information processing systems, pp. 860–867, 1991.
+
+Yehuda Koren. The bellkor solution to the netflix grand prize. Netflix prize documentation, 81:1–10, 2009.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+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.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.
+
+Jan Hendrik Metzen, Tim Genewein, Volker Fischer, and Bastian Bischoff. On detecting adversarial perturbations. arXiv preprint arXiv:1702.04267, 2017.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2574–2582, 2016.
+
+Nicolas Papernot, Ian Goodfellow, Ryan Sheatsley, Reuben Feinman, and Patrick McDaniel. cleverhans v1. 0.0: an adversarial machine learning library. arXiv preprint arXiv:1610.00768, 2016a.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016b.
+
+Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In Security and Privacy (EuroS&P), 2016 IEEE European Symposium on, pp. 372–387. IEEE, 2016c.
+
+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, 2016d.
+
+Pierre Sermanet and Yann LeCun. Traffic sign recognition with multi-scale convolutional networks. In Neural Networks (IJCNN), The 2011 International Joint Conference on, pp. 2809–2813. IEEE, 2011.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.

parse/train/rkA1f3NpZ/rkA1f3NpZ_content_list.json

@@ -0,0 +1,1091 @@
+[
+    {
+        "type": "text",
+        "text": "ENSEMBLE METHODS AS A DEFENSE TO ADVERSARIAL PERTURBATIONS AGAINST DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            821,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            195,
+            398,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            261,
+            544,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning has become the state of the art approach in many machine learning problems such as classification. It has recently been shown that deep learning is highly vulnerable to adversarial perturbations. Taking the camera systems of self-driving cars as an example, small adversarial perturbations can cause the system to make errors in important tasks, such as classifying traffic signs or detecting pedestrians. Hence, in order to use deep learning without safety concerns a proper defense strategy is required. We propose to use ensemble methods as a defense strategy against adversarial perturbations. We find that an attack leading one model to misclassify does not imply the same for other networks performing the same task. This makes ensemble methods an attractive defense strategy against adversarial attacks. We empirically show for the MNIST and the CIFAR-10 data sets that ensemble methods not only improve the accuracy of neural networks on test data but also increase their robustness against adversarial perturbations. ",
+        "bbox": [
+            233,
+            296,
+            764,
+            476
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            512,
+            334,
+            529
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, deep neural networks (DNNs) led to significant improvements in many areas ranging from computer vision (Krizhevsky et al., 2012; LeCun et al., 2015) to speech recognition (Hinton et al., 2012; Dahl et al., 2012). Some applications that can be solved with DNNs are sensitive from the security perspective, for example camera systems of self driving cars for detecting traffic signs or pedestrians (Papernot et al., 2016b; Sermanet & LeCun, 2011). Recently, it has been shown that DNNs can be highly vulnerable to adversaries (Szegedy et al., 2013; Goodfellow et al., 2014; Papernot et al., 2016a;b). The adversary produces some kind of noise on the input of the system to mislead its output behavior, producing undesirable outcomes or misclassification. Adversarial perturbations are carefully chosen in order to be hard, if not impossible, to be detected by the human eye (see figure 1). Attacks occur after the training of the DNN is completed. Furthermore, it has been shown that the exact structure of the DNN does not need to be known in order to mislead the system as one can send inputs to the unknown system in order to record its outputs to train a new DNN that imitates its behavior (Papernot et al., 2016b). Hence, in this manuscript it is assumed that the DNN and all its parameters are fully known to the adversary. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            742
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "There are many methods on how to attack neural networks appearing in the literature. Some of the most well-known ones are the Fast Gradient Sign Method (Goodfellow et al., 2014) and its iterative extension (Kurakin et al., 2016), DeepFool (Moosavi-Dezfooli et al., 2016), Jacobian-Based Saliency Map Attack (Papernot et al., 2016c), and the L-BFGS Attack (Szegedy et al., 2013). This shows the need of building neural networks that are themselves robust against any kind of adversarial perturbations. ",
+        "bbox": [
+            174,
+            750,
+            823,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Novel methods on defending against adversarial attacks are appearing more and more frequently in the literature. Some of those defense methods are to train the network with different kinds of adversarially perturbated training data (Goodfellow et al., 2014; Papernot et al., 2016c), the use of distillation to reduce the effectiveness of the perturbation (Papernot et al., 2016d) or to apply denoising autoencoders to preprocess the data used by the DNN (Gu & Rigazio, 2014). It also has been noted that adversarial attacks can be detected (Metzen et al., 2017; Feinman et al., 2017), but these detection systems are again vulnerable to adversarial attacks. To our knowledge, there is no method that can reliably defend or detect all kinds of adversarial attacks. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/9127e1674e35706ff747ebc18841ec99f6de0fdc31a8d2546cb04ce3a3c7f351.jpg",
+        "image_caption": [
+            "Figure 1: The first line shows original and correctly classified MNIST test data images. In the second line are the corresponding adversarial BIM attacks on a single classifier ( $\\epsilon = 0 . 2$ , $\\alpha = 0 . 0 2 5$ , $n = 8$ ) which predicts (from left to right): 6, 8, 1, 5, 9, 3, 0, 2, 2, and 4. Analogously, the third line corresponds to correctly predicted examples of the CIFAR-10 test data set. In the bottom line are the corresponding adversarial BIM attacks on a single classifier $\\epsilon = 0 . 0 2$ , $\\alpha = 0 . 0 0 2 5$ , $n = 8$ ) which predicts (from left to right): deer, cat, deer, ship, bird, deer, deer, frog, automobile, and automobile. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            823,
+            305
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            439,
+            821,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this manuscript, ensemble methods are used to obtain a classification system that is more robust against adversarial perturbations. The term ensemble method refers to constructing a set of classifiers used to classify new data points by the weighted or unweighted average of their predictions. Many ensemble methods have been introduced in the literature such as Bayesian averaging, Bagging (Breiman, 1996) and boosting (Dietterich et al., 2000). These methods frequently win machine learning competitions, for example the Netflix prize (Koren, 2009). Initial results on using ensembles of classifiers in adversarial context can be found in (Abbasi & Gagne, 2017; He et al., 2017). ´ However, to the best of our knowledge this is the first manuscript that empirically evaluates the robustness of ensemble methods to adversarial perturbations. ",
+        "bbox": [
+            173,
+            473,
+            825,
+            599
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One advantage of using ensemble methods as defense against adversarial perturbations is that they also increase the accuracy on unperturbed test data. This is not the case in general for other defense methods (see Table 4). However, in most applications a perturbated input can be considered as exception. Hence, it is desirable to obtain a state of the art result on unperturbed test data while making the model more robust against adversarial attacks. Another advantage is that ensemble methods can easily be combined with other defense mechanisms to improve the robustness against adversarial perturbations further (see Table 4). However, the advantages come at a cost of an increase of computational complexity and memory requirements which are proportional to the number of classifiers in the ensemble. ",
+        "bbox": [
+            174,
+            606,
+            825,
+            731
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper is organized as follows: In section 2, some methods for producing adversarial perturbations are briefly introduced. Section 3 describes the defense strategy proposed in this manuscript. In section 4, the previous methods are tested on the MNIST and CIFAR-10 data sets and are compared to other defense strategies appearing in the literature. Finally, in section 5 the conclusions are presented. ",
+        "bbox": [
+            174,
+            738,
+            823,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 ADVERSARIAL ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            401,
+            858
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, two methods for producing adversarial attacks shall be briefly described. In the following, let $\\theta$ be the parameters of a model, $x$ the input of the model and $y$ the output value associated with the input value $x$ . Further, let $J ( \\theta , x , y )$ be the cost function used to train the DNN. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "FAST GRADIENT SIGN METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            398,
+            118
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The fast gradient sign method (FGSM) by Goodfellow et al. (2014) simply adds some small perturbations of size $\\epsilon > 0$ to the input $x$ , ",
+        "bbox": [
+            174,
+            127,
+            823,
+            156
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cce3d456c4797ee7324a53e43b9c613f9d4ced3e97ae28a0c773dc5e7e882dde.jpg",
+        "text": "$$\nx _ { \\mathrm { F G S M } } = x + \\epsilon \\mathrm { s i g n } [ \\nabla _ { x } J ( \\theta , x , y ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            160,
+            612,
+            176
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where the gradient $\\nabla _ { x } J ( \\theta , x , y )$ can be computed using backpropagation. This relatively cheap and simple adversarial perturbation performs well on many DNNs. It is believed that this behavior is due to linear elements such as ReLUs or maxout networks in the DNNs (Goodfellow et al., 2014). ",
+        "bbox": [
+            174,
+            179,
+            826,
+            222
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "BASIC ITERATIVE METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            236,
+            366,
+            251
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The basic iterative method (BIM) by Kurakin et al. (2016) is an iterative extension of FGSM. The idea is to choose $\\epsilon \\geq \\alpha > 0$ and then apply some perturbations similar to FGSM to the input $x$ and repeat the process $n$ times: ",
+        "bbox": [
+            174,
+            260,
+            825,
+            303
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3469dd07c542132bb244182473836010248fdc3789acfef8d7af4cf80b740e05.jpg",
+        "text": "$$\n\\begin{array} { r l } & { x _ { 0 } = x , } \\\\ & { x _ { i } = \\mathrm { c l i p } _ { x , \\epsilon } \\left( x _ { i - 1 } + \\alpha \\mathrm { s i g n } [ \\nabla _ { x _ { i - 1 } } J ( \\theta , x _ { i - 1 } , y ) ] \\right) , } \\\\ & { x _ { \\mathrm { B I M } } = x _ { n } . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            308,
+            671,
+            363
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\mathrm { c l i p } _ { x , \\epsilon } ( \\cdot )$ refers to clipping the values of the adversarial sample so that they remain within an $\\epsilon$ -neighborhood of $x$ . ",
+        "bbox": [
+            171,
+            364,
+            823,
+            393
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 ENSEMBLE METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            412,
+            390,
+            429
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Ensemble methods are widely used to improve classifiers in supervised learning (Dietterich et al., 2000). The idea is to construct a set of classifiers that is used to classify a new data point by the weighted or unweighted average of their predictions. In order for an ensemble to outperform a single classifier it must be both accurate and diverse (Hansen & Salamon, 1990). A classifier is said to be accurate if it is better than random guessing, and a set of classifiers is said to be diverse if different classifiers make different errors on new data points. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            527
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As expected, when performing adversarial perturbations on new data points different classifiers perform quite differently on these points. Hence, we conclude that diversity on adversarial perturbations is given. Furthermore, for adversarial perturbations with small $\\epsilon > 0$ , the vast majority of classifiers was accurate. In other words, for any small $\\epsilon > 0$ , we could not find an adversarial attack that would turn the majority of classifiers into non-accurate classifiers. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In section 4, the following ensemble methods are used. Note that random initialization of the model parameters is used in all methods. ",
+        "bbox": [
+            174,
+            611,
+            821,
+            640
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "(i) The first method is to train multiple classifiers with the same network architecture but with random initial weights. This results in quite diverse classifiers with different final weights (Kolen & Pollack, 1991).   \n(ii) The second method is to train multiple classifiers with different but similar network architectures to ensure obtaining a set of even more diverse classifiers. That is, extra filters are used in one classifier or an extra convolution layer is added to another classifier.   \n(iii) Third, Bagging (Breiman, 1996) is used on the training data. The term Bagging is derived from bootstrap aggregation and it consists of drawing $m$ samples with replacement from the training data set of $m$ data points. Each of these new data sets is called a bootstrap replicate. At average each of them contains $6 3 . 2 \\%$ of the training data, where many data points are repeated in the bootstrap replicates. A different bootstrap replicate is used as training data for each classifier in the ensemble.   \n(iv) The last method is to add some small Gaussian noise to the training data so that all classifiers are trained on similar but different training sets. Note that adding Gaussian noise to the training data also makes each classifier somewhat more robust against adversarial perturbations. ",
+        "bbox": [
+            179,
+            650,
+            825,
+            871
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Once an ensemble of classifiers is trained, it predicts by letting each classifier vote for a label. More specifically, the predicted value is chosen to be the label that maximizes the average of the output probabilities from the classifiers in the ensemble. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In order to attack a network with the methods from section 2 the gradient $\\nabla _ { x } J ( \\theta , x , y )$ must be computed. However, obtaining the gradient for an ensemble requires to calculate the gradient of each of its classifiers. Nevertheless, the following two methods are used to estimate the gradient of an ensemble, which are referred to as Grad. 1 and Grad. 2 for the rest of this manuscript: ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Grad. 1 Use $\\nabla _ { x } J ( \\theta _ { i } , x , y )$ of the $i$ -th classifier. This is clearly not the correct gradient for an ensemble. But the question is whether an attack with this gradient can already mislead all classifiers in the ensemble in a similar manner.   \nGrad. 2 Compute the average of the gradients $\\begin{array} { r } { \\frac { 1 } { n } \\sum _ { i } \\nabla _ { x } J ( \\theta _ { i } , x , y ) \\ } \\end{array}$ from all classifiers in the ensemble. ",
+        "bbox": [
+            173,
+            171,
+            825,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A comparison of the effects of these two gradients for attacking ensembles can be found in section 4. ",
+        "bbox": [
+            173,
+            260,
+            820,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            326,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section the ensemble methods from section 3 are empirically evaluated on the MNIST (LeCun et al., 1998) and the CIFAR-10 (Krizhevsky & Hinton, 2009) data sets which are scaled to the unit interval. All experiments have been performed on ensembles of 10 classifiers. Note that this choice has been done for comparability. That is, in some cases the best performance was already reached with ensembles of less classifiers while in others more classifiers might improve the results. ",
+        "bbox": [
+            173,
+            328,
+            825,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A summary of the experimental results can be found in Table 2 and the corresponding visualization in Figure 2. A comparison of ensembles with other defense methods and a combination of those with ensembles can be found in Table 4. In the following all FGSM perturbations are done with $\\epsilon = 0 . 3$ on MNIST and with $\\epsilon = 0 . 0 3$ on CIFAR-10. Furthermore, all BIM perturbations are done with $\\epsilon = 0 . 2$ , $\\alpha = 0 . 0 2 5$ and $n = 8$ iterations on MNIST and with $\\epsilon = 0 . 0 2$ , $\\alpha = 0 . 0 0 2 5$ and $n = 8$ on CIFAR-10. The abbreviations in Table 2 and in Figure 2 shall be interpreted in the following way: Rand. Ini. refers to random initialization of the weights of the neural network, Mix. Mod. means that the network architecture was slightly different for each classifier in an ensemble, Bagging refers to classifiers trained on bootstrap replicates of the training data, and Gauss noise implies that small Gaussian noise has been added to the training data. Each ensemble is attacked with FGSM and BIM based on the gradients from Grad. 1 and Grad. 2. In Table 2, the term Single refers to evaluating a single classifier. ",
+        "bbox": [
+            173,
+            404,
+            825,
+            570
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            587,
+            230,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The MNIST data set consists of 60,000 training and 10,000 test data samples of black and white encoded handwritten digits. The objective is to classify these digits in the range from 0 to 9. A selection of images from the data set and some adversarial perturbations can be found in the top two rows of figure 1. In the experiments, the network architecture in Table 1 is used and it is trained with 10 epochs. All results from the experiments are summarized in Table 2. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            683
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "On unperturbed test data the classification accuracy is roughly $9 9 \\%$ . The difference between single classifiers and ensembles is below one percent throughout. The ensembles slightly outperform the single classifiers in all cases. ",
+        "bbox": [
+            176,
+            689,
+            823,
+            731
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/843e66b24bf43be7e2ae22d70ae68de381104eeb1be51c33d35fe4b621d0332f.jpg",
+        "table_caption": [
+            "Table 1: MNIST Network Architecture "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer Type</td><td>Parameters</td></tr><tr><td>Relu Convolutional</td><td>32 filters (3×3)</td></tr><tr><td>Relu Convolutional</td><td>32 filters (3×3)</td></tr><tr><td>Max Pooling</td><td>2×2</td></tr><tr><td>Relu Fully Connected</td><td>128 units</td></tr><tr><td>Dropout</td><td>0.5</td></tr><tr><td>Relu Fully Connected</td><td>10 units</td></tr><tr><td>Softmax</td><td>10 units</td></tr></table>",
+        "bbox": [
+            354,
+            787,
+            642,
+            915
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/13090d172830a0cb5bbf195e9aa41fa9bd26a280dd838662ea9b01090a23afca.jpg",
+        "table_caption": [
+            "Table 2: Experimental results on the MNIST and the CIFAR-10 data sets ",
+            "MNIST Accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Test Data</td><td colspan=\"2\">No Attack</td><td colspan=\"2\">Grad. 1</td><td>Grad. 2</td></tr><tr><td>Type</td><td>Method</td><td>Single</td><td>Ensemble</td><td>Single</td><td>Ensemble</td><td>Ensemble</td></tr><tr><td rowspan=\"4\">FGSM</td><td>Rand. Ini.</td><td>0.9912</td><td>0.9942</td><td>0.3791</td><td>0.6100</td><td>0.4517</td></tr><tr><td>Mix. Mod.</td><td>0.9918</td><td>0.9942</td><td>0.3522</td><td>0.5681</td><td>0.4609</td></tr><tr><td>Bagging</td><td>0.9900</td><td>0.9927</td><td>0.4045</td><td>0.6738</td><td>0.5716</td></tr><tr><td>Gauss Noise</td><td>0.9898</td><td>0.9920</td><td>0.5587</td><td>0.7816</td><td>0.7043</td></tr><tr><td rowspan=\"4\">BIM</td><td>Rand. Ini.</td><td>0.9912</td><td>0.9942</td><td>0.0906</td><td>0.6518</td><td>0.8875</td></tr><tr><td>Mix.Mod.</td><td>0.9918</td><td>0.9942</td><td>0.0582</td><td>0.6656</td><td>0.9076</td></tr><tr><td>Bagging</td><td>0.9900</td><td>0.9927</td><td>0.1110</td><td>0.7068</td><td>0.9233</td></tr><tr><td>Gauss Noise</td><td>0.9898</td><td>0.9920</td><td>0.5429</td><td>0.9152</td><td>0.9768</td></tr></table>",
+        "bbox": [
+            223,
+            146,
+            771,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/fe88849a49201d178aa57d143d55816b47f6f4b04ea91c98318245b1a90b6fd2.jpg",
+        "table_caption": [
+            "CIFAR-10 Accuracy "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">Test Data</td><td colspan=\"2\">No Attack</td><td colspan=\"2\">Grad. 1</td><td>Grad. 2</td></tr><tr><td>Type</td><td>Method</td><td>Single</td><td>Ensemble</td><td>Single</td><td>Ensemble</td><td>Ensemble</td></tr><tr><td rowspan=\"4\">FGSM</td><td>Rand. Ini.</td><td>0.7984</td><td>0.8448</td><td>0.1778</td><td>0.4538</td><td>0.3302</td></tr><tr><td>Mix. Mod.</td><td>0.7898</td><td>0.8400</td><td>0.1643</td><td>0.4339</td><td>0.3140</td></tr><tr><td>Bagging</td><td>0.7815</td><td>0.8415</td><td>0.1822</td><td>0.4788</td><td>0.3571</td></tr><tr><td>Gauss Noise</td><td>0.7160</td><td>0.7687</td><td>0.2966</td><td>0.6097</td><td>0.4707</td></tr><tr><td rowspan=\"4\">BIM</td><td>Rand. Ini.</td><td>0.7984</td><td>0.8448</td><td>0.1192</td><td>0.5232</td><td>0.6826</td></tr><tr><td>Mix. Mod.</td><td>0.7898</td><td>0.8400</td><td>0.1139</td><td>0.5259</td><td>0.6768</td></tr><tr><td>Bagging</td><td>0.7815</td><td>0.8415</td><td>0.1280</td><td>0.5615</td><td>0.7166</td></tr><tr><td>Gauss Noise</td><td>0.7160</td><td>0.7687</td><td>0.3076</td><td>0.6735</td><td>0.7277</td></tr></table>",
+        "bbox": [
+            223,
+            371,
+            771,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This picture changes dramatically if the networks are attacked by one of the methods described in section 2. Using the FGSM attack with gradients from Grad. 1 on a single classifier, the classification rate drops down to a range of roughly $3 5 \\% { - } 5 6 \\%$ . The ensembles perform significantly better by producing an accuracy of $5 7 \\% - 7 8 \\%$ . Evaluating the same with gradients from Grad. 2 it turns out that ensemble methods still obtain an accuracy of $45 \\% - 7 0 \\%$ . The higher accuracy of Grad. 1 is expected since in contrast to Grad. 2 it computes the gradients with respect to just one classifier. Nevertheless, the ensembles outperform single classifiers in each case by approximately $7 \\% - 2 2 \\%$ . ",
+        "bbox": [
+            174,
+            589,
+            825,
+            688
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The decrease of the accuracy is even more extreme for single classifiers if the BIM method is used. Here, the accuracy can be as low as around $6 \\%$ and only the classifiers trained with Gaussian noise significantly exceed the $10 \\%$ . The accuracy of the ensemble methods against attacks using Grad. 1 is considerably higher with $6 5 \\% { - } 9 2 \\%$ . Furthermore, ensembles are even more robust against BIM attacks based on Grad. 2 with a correct classification rate of $89 \\% - 9 8 \\%$ . It is surprising that BIM attacks using Grad. 1 are more successful than those using Grad. 2, because Grad. 1 only attacks a single classifier in the ensemble. Concluding, the ensemble methods outperform single classifiers significantly by $3 7 \\% 8 5 \\%$ on BIM attacks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            805
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Focusing on the different defense strategies, we observe that using random initialization of the network weights as well as using several networks of similar architectures for an ensemble generally improves the robustness against adversarial attacks considerably in comparison with single classifiers. Bagging outperforms both of the previous methods on adversarial perturbations, but performs slightly worse on unperturbed test data. Using ensembles with small Gaussian noise on the training data results in the best defense mechanism against adversarial attacks. This may be due to the fact that using additive noise on the training data already makes every single classifier in the ensemble more robust against adversarial perturbations. On the down-side, adding Gaussian noise to the training data performs worst from all considered ensemble methods on test data. However, such an ensemble still performs better than all single classifiers on MNIST. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1c4ae0569cb52f4202724269f5dffd84f378a5db113a84d8cc0257b4219ef28.jpg",
+        "image_caption": [
+            "Figure 2: Visual comparisons of the accuracies presented in Table 2. Compared are the MNIST (top row) and CIFAR-10 (bottom row) data sets on the FGSM (left column) and the BIM (right column) attacks. Grad. 1 Single refers to attacks based on Grad. 1 on single classifiers, Grad. 1 Ensemble refers to attacks based on Grad. 1 on ensembles, Grad. 2 Ensemble refers to attacks based on Grad. 2 on ensemble classifiers, No Attack Single refers to single classifier on unperturbed data, and finally No Attack Ensemble refers to ensemble classifiers on unperturbed data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            102,
+            821,
+            507
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            640,
+            823,
+            669
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            698,
+            251,
+            712
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The CIFAR-10 data set consists of 50,000 training and 10,000 test data samples of three-color component encoded images of ten mutually exclusive classes: airplane, automobile, bird, cat, deer, dog, frog, horse, ship, and truck. A selection of images from the data set and some adversarial perturbations can be found in the two bottom rows of figure 1. In all experiments the network architecture described in Table 3 is used and the networks are trained with 25 epochs. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In general, the observations on the MNIST data set are confirmed by the experiments on CIFAR10. Since the latter data set is more demanding to classify, the overall classification rate is already lower in the attack-free case, where single classifiers reach an accuracy of roughly $7 2 \\% - 8 0 \\%$ , while ensembles show a higher accuracy of $7 7 \\% - 8 4 \\%$ . Note that there are network architectures in the literature that outperform our classifiers considerably on test data (Graham, 2014). ",
+        "bbox": [
+            176,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The FGSM attacks on single classifiers using method Grad. 1 show a drop-down of the accuracy to $1 6 \\% - 3 0 \\%$ . In contrast, ensembles are significantly better reaching accuracies of $4 3 \\% - 6 1 \\%$ when attacked using Grad. 1 and $3 1 \\% - 4 7 \\%$ when attacked with Grad. 2. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/1f5c6b56f480bd1b140bd3f20d5b69de9fe6e37926a44f5493d3b90dc331acf5.jpg",
+        "table_caption": [
+            "Table 3: CIFAR-10 Network Architecture "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer Type</td><td>Parameters</td></tr><tr><td>Relu Convolutional Relu Convolutional Max Pooling Dropout</td><td>32 filters (3×3) 32 filters (3×3) 2×2 0.2</td></tr><tr><td>Relu Convolutional Relu Convolutional Max Pooling Dropout Relu Convolutional</td><td>64 filters (3×3) 64 filters (3×3) 2×2 0.3</td></tr><tr><td>Relu Convolutional</td><td>128 filters (3×3)</td></tr><tr><td></td><td>128 filters (3×3)</td></tr><tr><td>Max Pooling Dropout Relu Fully Connected Dropout Relu Fully Connected Softmax</td><td>2×2 0.4 512 units 0.5 10 units</td></tr></table>",
+        "bbox": [
+            349,
+            127,
+            647,
+            378
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When using BIM attacks accuracies for single classifiers lie between $11 \\%$ and $31 \\%$ . Again, the ensemble methods outperform the single classifiers reaching accuracies of $5 2 \\% - 6 7 \\%$ when attacked using Grad. 1 and $6 8 \\% - 7 3 \\%$ when attacked with Grad. 2. ",
+        "bbox": [
+            176,
+            422,
+            825,
+            464
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The same observations as on the MNIST data set can be made on the CIFAR-10 data set. All ensemble methods outperform single classifiers when comparing their robustness against adversarial perturbations. FGSM attacks on an ensemble using Grad. 2 outperform those using Grad. 1, as expected. Similar to the MNIST experiments, when using BIM attacks, ensembles are surprisingly more robust against gradient attacks from Grad. 2 than against gradient attacks from Grad. 1. The reason for this might be that the gradient portion from different classifiers using Grad. 2 in the ensemble try to reach a different local maximum and block each other in the following iterations. ",
+        "bbox": [
+            174,
+            472,
+            825,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As already observed on the MNIST data set, Bagging performs better than random initialization and than using similar but different network architectures. Again, adding small Gaussian noise on the training data performs best on adversarial perturbations but relatively poor on real test data on CIFAR-10. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            632
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "COMPARISON WITH OTHER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            662,
+            437,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we compare the previous results with two of the most popular defense methods: adversarial training (Goodfellow et al., 2014; Papernot et al., 2016c) and defensive distillation (Papernot et al., 2016d). Furthermore, we show the positive effects of combining those methods with ensembles. For simplicity, we only consider the gradient Grad. 2 whenever an ensemble is attacked. The results are summarized in Table 4. Here, the content shall be interpreted in the following way: Bagging refers to ensembles trained with bagging, Adv. Train. to adversarial training, Def. Dist. to defensive distillation, the operator $^ +$ to combinations of the previous methods, bold text to the best performance of the first three methods, and the asterisk to the best method including combinations of defensive strategies. ",
+        "bbox": [
+            173,
+            694,
+            825,
+            819
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training (AT) is a method that uses FGSM as regularizer of the original cost function: ",
+        "bbox": [
+            171,
+            825,
+            810,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0799c5d1e875491fd1a5589a7fb9dc0d4477b0486ce758d98c78ef6ce6d92914.jpg",
+        "text": "$$\nJ _ { A T } ( \\theta , x , y ) = \\rho J ( \\theta , x , y ) + ( 1 - \\rho ) J ( \\theta , x + \\epsilon \\operatorname { s i g n } ( \\nabla _ { x } J ( \\theta , x , y ) ) , y ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            264,
+            859,
+            732,
+            877
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where $\\rho \\in [ 0 , 1 ]$ . This method iteratively increases the robustness against adversarial perturbations.   \nIn our experiments, we use $\\rho = { \\textstyle { \\frac { 1 } { 2 } } }$ as proposed in Goodfellow et al. (2014). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/8d2ec5d24af5b37ce6df0e36186c30aa5e15290e017bdbc24fd7b596ad2d057c.jpg",
+        "table_caption": [
+            "Table 4: Accuracies of different defense mechanisms "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">MNIST</td><td colspan=\"3\">CIFAR-10</td></tr><tr><td>Methods</td><td>No Attack</td><td>FGSM</td><td>BIM</td><td>No Attack</td><td>FGSM</td><td>BIM</td></tr><tr><td>Bagging</td><td>0.9927*</td><td>0.5716</td><td>0.9233</td><td>0.8415*</td><td>0.3571</td><td>0.7166*</td></tr><tr><td>Adv.Train.</td><td>0.9902</td><td>0.3586</td><td>0.5420</td><td>0.7712</td><td>0.1778</td><td>0.3107</td></tr><tr><td>Def. Dist.</td><td>0.9840</td><td>0.0798</td><td>0.3829</td><td>0.7140</td><td>0.1828</td><td>0.3635</td></tr><tr><td>Bagging + Adv. Train.</td><td>0.9927*</td><td>0.8703*</td><td>0.9840*</td><td>0.8320</td><td>0.5010*</td><td>0.7017</td></tr><tr><td>Bagging + Def. Dist.</td><td>0.9875</td><td>0.0954</td><td>0.4514</td><td>0.7323</td><td>0.1839</td><td>0.4569</td></tr></table>",
+        "bbox": [
+            179,
+            126,
+            813,
+            253
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In defensive distillation a teacher model $F$ is trained on a training data set $X$ . Then smoothed labels at temperature $T$ are computed by ",
+        "bbox": [
+            173,
+            279,
+            823,
+            309
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f74cb388ecbfcc9bcc8746b5a204a5033df7c7f6d4d0ddb6833537f0007427d.jpg",
+        "text": "$$\nF ^ { T } ( X ) = \\left[ \\frac { \\exp ( F _ { i } ( X ) / T ) } { \\sum _ { i = 1 } ^ { N } \\exp ( F _ { i } ( X ) / T ) } \\right] _ { i \\in \\{ 1 , \\ldots , N \\} } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            314,
+            653,
+            361
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { i } ( X )$ refers to the probability of the $i$ -th out of $N$ possible classes. A distilled network is a network that is trained on the training data $X$ using the smoothed labels $F ^ { T } ( X )$ . In the following, we use $T = 1 0$ based on the experimental results in Papernot et al. (2016d). ",
+        "bbox": [
+            174,
+            367,
+            825,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We found that single networks trained with adversarial training or defensive distillation have a lower accuracy than ensembles trained with bagging (see the top three rows in Table 4). This is not only the case on the considered attacked data but also on unperturbated test data. Combining ensembles with adversarial training can improve the robustness against adversarial perturbations further, while a combination with defensive distillation does not reveal the same tendency (see the two bottom rows in Table 4). We emphasize that already the standard ensemble method does not only outperform both adversarial training and defensive distillation throughout but also has the overall highest accuracy on unperturbated test data. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            529
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            549,
+            318,
+            565
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "With the rise of deep learning as the state-of-the-art approach for many classification tasks, researchers noted that neural networks are highly vulnerable to adversarial perturbations. This is particularly problematic when neural networks are used in security sensitive applications such as autonomous driving. Hence, with the development of more efficient attack methods against neural networks it is desirable to obtain neural networks that are themselves robust against adversarial attacks. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            665
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this manuscript, it is shown that several ensemble methods such as random initialization or Bagging do not only increase the accuracy on the test data, but also make the classifiers considerably more robust against certain adversarial attacks. We consider ensemble methods as sole defense methods, but more robust classifiers can be obtained by combining ensemble methods with other defense mechanisms such as adversarial training. Although only having tested simple attack scenarios, it can be expected that ensemble methods may improve the robustness against other adversarial attacks. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            770
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            791,
+            285,
+            808
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Mahdieh Abbasi and Christian Gagne. Robustness to adversarial examples through an ensemble of ´ specialists. arXiv preprint arXiv:1702.06856, 2017. ",
+        "bbox": [
+            173,
+            816,
+            823,
+            844
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Leo Breiman. Bagging predictors. Machine learning, 24(2):123–140, 1996. ",
+        "bbox": [
+            176,
+            856,
+            671,
+            871
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "George E Dahl, Dong Yu, Li Deng, and Alex Acero. Context-dependent pre-trained deep neural networks for large-vocabulary speech recognition. IEEE Transactions on audio, speech, and language processing, 20(1):30–42, 2012. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Thomas G Dietterich et al. Ensemble methods in machine learning. Multiple classifier systems, 1857:1–15, 2000. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Reuben Feinman, Ryan R Curtin, Saurabh Shintre, and Andrew B Gardner. Detecting adversarial samples from artifacts. arXiv preprint arXiv:1703.00410, 2017. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            173,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Graham. Fractional max-pooling. arXiv preprint arXiv:1412.6071, 2014. ",
+        "bbox": [
+            176,
+            217,
+            723,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Shixiang Gu and Luca Rigazio. Towards deep neural network architectures robust to adversarial examples. arXiv preprint arXiv:1412.5068, 2014. ",
+        "bbox": [
+            171,
+            242,
+            823,
+            271
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lars Kai Hansen and Peter Salamon. Neural network ensembles. IEEE transactions on pattern analysis and machine intelligence, 12(10):993–1001, 1990. ",
+        "bbox": [
+            171,
+            280,
+            823,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Warren He, James Wei, Xinyun Chen, Nicholas Carlini, and Dawn Song. Adversarial example defenses: Ensembles of weak defenses are not strong. arXiv preprint arXiv:1706.04701, 2017. ",
+        "bbox": [
+            171,
+            318,
+            823,
+            347
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            173,
+            354,
+            825,
+            412
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John F Kolen and Jordan B Pollack. Back propagation is sensitive to initial conditions. In Advances in neural information processing systems, pp. 860–867, 1991. ",
+        "bbox": [
+            173,
+            421,
+            823,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yehuda Koren. The bellkor solution to the netflix grand prize. Netflix prize documentation, 81:1–10, 2009. ",
+        "bbox": [
+            173,
+            459,
+            821,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009. ",
+        "bbox": [
+            173,
+            497,
+            823,
+            526
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            173,
+            535,
+            823,
+            578
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            174,
+            587,
+            823,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "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,
+            625,
+            823,
+            655
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            174,
+            662,
+            823,
+            693
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jan Hendrik Metzen, Tim Genewein, Volker Fischer, and Bastian Bischoff. On detecting adversarial perturbations. arXiv preprint arXiv:1702.04267, 2017. ",
+        "bbox": [
+            171,
+            700,
+            823,
+            731
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 2574–2582, 2016. ",
+        "bbox": [
+            176,
+            739,
+            823,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Ian Goodfellow, Ryan Sheatsley, Reuben Feinman, and Patrick McDaniel. cleverhans v1. 0.0: an adversarial machine learning library. arXiv preprint arXiv:1610.00768, 2016a. ",
+        "bbox": [
+            171,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016b. ",
+        "bbox": [
+            176,
+            829,
+            823,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Somesh Jha, Matt Fredrikson, Z Berkay Celik, and Ananthram Swami. The limitations of deep learning in adversarial settings. In Security and Privacy (EuroS&P), 2016 IEEE European Symposium on, pp. 372–387. IEEE, 2016c. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "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, 2016d. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet and Yann LeCun. Traffic sign recognition with multi-scale convolutional networks. In Neural Networks (IJCNN), The 2011 International Joint Conference on, pp. 2809–2813. IEEE, 2011. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            174,
+            207,
+            821,
+            234
+        ],
+        "page_idx": 9
+    }
+]