Add files using upload-large-folder tool

parse/train/BkevoJSYPB/BkevoJSYPB.md

@@ -0,0 +1,656 @@
+# DIFFERENTIATION OF BLACKBOX COMBINATORIAL SOLVERS
+
+Marin Vlastelica1∗, Anselm Paulus1∗, V´ıt Musil2, Georg Martius1, Michal Rol´ınek1
+
+1 Max-Planck-Institute for Intelligent Systems, Tubingen, Germany ¨   
+2 Universita degli Studi di Firenze, Italy \`   
+{marin.vlastelica, anselm.paulus, georg.martius, michal.rolinek}@tuebingen.mpg.de   
+vit.musil@unifi.it
+
+# ABSTRACT
+
+Achieving fusion of deep learning with combinatorial algorithms promises transformative changes to artificial intelligence. One possible approach is to introduce combinatorial building blocks into neural networks. Such end-to-end architectures have the potential to tackle combinatorial problems on raw input data such as ensuring global consistency in multi-object tracking or route planning on maps in robotics. In this work, we present a method that implements an efficient backward pass through blackbox implementations of combinatorial solvers with linear objective functions. We provide both theoretical and experimental backing. In particular, we incorporate the Gurobi MIP solver, Blossom V algorithm, and Dijkstra’s algorithm into architectures that extract suitable features from raw inputs for the traveling salesman problem, the min-cost perfect matching problem and the shortest path problem. The code is available at
+
+https://github.com/martius-lab/blackbox-backprop.
+
+# 1 INTRODUCTION
+
+The toolbox of popular methods in computer science currently sees a split into two major components. On the one hand, there are classical algorithmic techniques from discrete optimization – graph algorithms, SAT-solvers, integer programming solvers – often with heavily optimized implementations and theoretical guarantees on runtime and performance. On the other hand, there is the realm of deep learning allowing data-driven feature extraction as well as the flexible design of end-to-end architectures. The fusion of deep learning with combinatorial optimization is desirable both for foundational reasons – extending the reach of deep learning to data with large combinatorial complexity – and in practical applications. These often occur for example in computer vision problems that require solving a combinatorial sub-task on top of features extracted from raw input such as establishing global consistency in multi-object tracking from a sequence of frames.
+
+The fundamental problem with constructing hybrid architectures is differentiability of the combinatorial components. State-of-the-art approaches pursue the following paradigm: introduce suitable approximations or modifications of the objective function or of a baseline algorithm that eventually yield a differentiable computation. The resulting algorithms are often sub-optimal in terms of runtime, performance and optimality guarantees when compared to their unmodified counterparts. While the sources of sub-optimality vary from example to example, there is a common theme: any differentiable algorithm in particular outputs continuous values and as such it solves a relaxation of the original problem. It is well-known in combinatorial optimization theory that even strong and practical convex relaxations induce lower bounds on the approximation ratio for large classes of problems (Raghavendra, 2008; Thapper & Zivn ˇ y´, 2017) which makes them inherently sub-optimal. This inability to incorporate the best implementations of the best algorithms is unsatisfactory.
+
+In this paper, we propose a method that, at the cost of one hyperparameter, implements a backward pass for a blackbox implementation of a combinatorial algorithm or a solver that optimizes a linear objective function. This effectively turns the algorithm or solver into a composable building block of neural network architectures, as illustrated in Fig. 1. Suitable problems with linear objective include classical problems such as SHORTEST-PATH, TRAVELING-SALESMAN (TSP), MIN-COSTPERFECT-MATCHING, various cut problems as well as entire frameworks such as integer programs (IP), Markov random fields (MRF) and conditional random fields (CRF).
+
+![](images/d9c8e2dacd0c0eb13bcfff5d9eb2f9ae98c1624ffa536006ff07f824ee59321e.jpg)  
+Figure 1: Architecture design enabled by Theorem 1. Blackbox combinatorial solver embedded into a neural network.
+
+The main technical challenge boils down to providing an informative gradient of a piecewise constant function. To that end, we are able to heavily leverage the minimization structure of the underlying combinatorial problem and efficiently compute a gradient of a continuous interpolation. While the roots of the method lie in loss-augmented inference, the employed mathematical technique for continuous interpolation is novel. The computational cost of the introduced backward pass matches the cost of the forward pass. In particular, it also amounts to one call to the solver.
+
+In experiments, we train architectures that contain unmodified implementations of the following efficient combinatorial algorithms: general-purpose mixed-integer programming solver Gurobi (Gurobi Optimization, 2019), state-of-the-art C implementation of MIN-COST-PERFECTMATCHING algorithm – Blossom V (Kolmogorov, 2009) and Dijkstra’s algorithm (Dijkstra, 1959) for SHORTEST-PATH. We demonstrate that the resulting architectures train without sophisticated tweaks and are able to solve tasks that are beyond the capabilities of conventional neural networks.
+
+# 2 RELATED WORK
+
+Multiple lines of work lie at the intersection of combinatorial algorithms and deep learning. We primarily distinguish them by their motivation.
+
+Motivated by applied problems. Even though computer vision has seen a substantial shift from combinatorial methods to deep learning, some problems still have a strong combinatorial aspect and require hybrid approaches. Examples include multi-object tracking (Schulter et al., 2017), semantic segmentation (Chen et al., 2018), multi-person pose estimation (Pishchulin et al., 2016; Song et al., 2018), stereo matching (Knobelreiter et al. ¨ , 2017) and person re-identification (Ye et al., 2017). The combinatorial algorithms in question are typically Markov random fields (MRF) (Chen et al., 2015), conditional random fields (CRF) (Marin et al., 2019), graph matching (Ye et al., 2017) or integer programming (Schulter et al., 2017). In recent years, a plethora of hybrid end-to-end architectures have been proposed. The techniques used for constructing the backward pass range from employing various relaxations and approximations of the combinatorial problem (Chen et al., 2015; Zheng et al., 2015) over differentiating a fixed number of iterations of an iterative solver (Paschalidou et al., 2018; Tompson et al., 2014; Liu et al., 2015) all the way to relying on the structured SVM framework (Tsochantaridis et al., 2005; Chen et al., 2015).
+
+Motivated by “bridging the gap”. Building links between combinatorics and deep learning can also be viewed as a foundational problem; for example, (Battaglia et al., 2018) advocate that “combinatorial generalization must be a top priority for AI”. One such line of work focuses on designing architectures with algorithmic structural prior – for example by mimicking the layout of a Turing machine (Sukhbaatar et al., 2015; Vinyals et al., 2015; Graves et al., 2014; 2016) or by promoting behaviour that resembles message-passing algorithms as it is the case in Graph Neural Networks and related architectures (Scarselli et al., 2009; Li et al., 2016; Battaglia et al., 2018). Another approach is to provide neural network building blocks that are specialized to solve some types of combinatorial problems such as satisfiability (SAT) instances (Wang et al., 2019), mixed integer programs (Ferber et al., 2019), sparse inference (Niculae et al., 2018), or submodular maximization (Tschiatschek et al., 2018). A related mindset of learning inputs to an optimization problem gave rise to the “predict-and-optimize” framework and its variants (Elmachtoub & Grigas, 2017; Demirovic et al., 2019; Mandi et al., 2019). Some works have directly addressed the question of learning combinatorial optimization algorithms such as the TRAVELING-SALESMAN-PROBLEM in (Bello et al., 2017) or its vehicle routing variants (Nazari et al., 2018). A recent approach also learns combinatorial algorithms via a clustering proxy (Wilder et al., 2019).
+
+There are also efforts to bridge the gap in the opposite direction; to use deep learning methods to improve state-of-the-art combinatorial solvers, typically by learning (otherwise hand-crafted) heuristics. Some works have again targeted the TRAVELING-SALESMAN-PROBLEM (Kool et al., 2019; Deudon et al., 2018; Bello et al., 2017) as well as other NP-Hard problems (Li et al., 2018). Also, more general solvers received some attention; this includes SAT-solvers (Selsam & Bjørner, 2019; Selsam et al., 2019), integer programming solvers (often with learning branch-and-bound rules) (Khalil et al., 2016; Balcan et al., 2018; Gasse et al., 2019) and SMT-solvers (satisfiability modulo theories)(Balunovic et al., 2018).
+
+# 3 METHOD
+
+Let us first formalize the notion of a combinatorial solver. We expect the solver to receive continuous input $w \in W \subseteq \mathbb { R } ^ { N }$ (e.g. edge weights of a fixed graph) and return discrete output $y$ from some finite set $Y$ (e.g. all traveling salesman tours on a fixed graph) that minimizes some cost $\mathbf { c } ( w , y )$ (e.g. length of the tour). More precisely, the solver maps
+
+$$
+w \mapsto y ( w ) \quad { \mathrm { s u c h ~ t h a t } } \quad y ( w ) = \arg \operatorname* { m i n } _ { y \in Y } \mathbf { \exp } ( w , y ) .
+$$
+
+We will restrict ourselves to objective functions $\mathbf { c } ( w , y )$ that are linear , namely $\mathbf { c } ( w , y )$ may be represented as
+
+$$
+\mathbf { c } ( w , y ) = w \cdot \phi ( y ) \quad { \mathrm { f o r ~ } } w \in W { \mathrm { ~ a n d ~ } } y \in Y
+$$
+
+in which $\phi \colon Y  \mathbb { R } ^ { N }$ is an injective representation of $y \in Y$ in $\mathbb { R } ^ { N }$ . For brevity, we omit the mapping $\phi$ and instead treat elements of $Y$ as discrete points in $\mathbb { R } ^ { N }$ .
+
+Note that such definition of a solver is still very general as there are no assumptions on the set of constraints or on the structure of the output space $Y$ .
+
+Example 1 (Encoding shortest-path problem). If $G = ( V , E )$ is a given graph with vertices $s , t \in V$ , the combinatorial solver for the $( s , t )$ -SHORTEST-PATH would take edge weights $w \in W = \mathbb { R } ^ { | E | }$ as input and produce the shortest path $y ( w )$ represented as $\phi ( y ) \subseteq \{ 0 , 1 \} ^ { | E | }$ an indicator vector of the selected edges. The cost function is then indeed the inner product $\mathbf { c } ( \dot { w } , y ) = w \cdot { \phi } ( y )$ .
+
+The task to solve during back-propagation is the following. We receive the gradient $\mathrm { d } L / \mathrm { d } y$ of the global loss $L$ with respect to solver output $y$ at a given point $\hat { y } = y ( \hat { w } )$ . We are expected to return $\mathrm { d } L / \mathrm { d } w$ , the gradient of the loss with respect to solver input $w$ at a point $\hat { w }$ .
+
+Since $Y$ is finite, there are only finitely many values of $y ( w )$ . In other words, this function of $w$ is piecewise constant and the gradient is identically zero or does not exist (at points of jumps). This should not come as a surprise; if one does a small perturbation to edge weights of a graph, one usually does not change the optimal TSP tour and on rare occasions alters it drastically. This has an important consequence:
+
+The fundamental problem with differentiating through combinatorial solvers is not the lack of differentiability; the gradient exists almost everywhere. However, this gradient is a constant zero and as such is unhelpful for optimization.
+
+Accordingly, we will not rely on standard techniques for gradient estimation (see (Mohamed et al., 2019) for a comprehensive survey).
+
+![](images/ccc85f2ab1b95aa0779c74202ea55b1e442adf5cc1b1c62194403e325eb252a6.jpg)  
+Figure 2: Continuous interpolation of a piecewise constant function. (a) $f _ { \lambda }$ for a small value of $\lambda$ ; the set $W _ { \mathrm { e q } } ^ { \lambda }$ is still substantial and only two interpolators $g _ { 1 }$ and $g _ { 2 }$ are incomplete. Also, all interpolators are 0-interpolators. (b) $f _ { \lambda }$ for a high value of $\lambda$ ; most interpolators are incomplete and we also encounter a $\delta$ -interpolator $g _ { 3 }$ (between $y _ { 1 }$ and $y _ { 2 }$ ) which attains the value $f ( y _ { 1 } )$ δ-away from the set $P _ { 1 }$ . Despite losing some local structure for high $\lambda$ , the gradient of $f _ { \lambda }$ is still informative.
+
+First, we simplify the situation by considering the linearization $f$ of $L$ at the point $\hat { y }$ . Then for
+
+$$
+f ( y ) = L ( \hat { y } ) + \frac { \mathrm { d } L } { \mathrm { d } y } ( \hat { y } ) \cdot ( y - \hat { y } ) \quad \mathrm { w e ~ h a v e } \quad \frac { \mathrm { d } f \big ( y ( w ) \big ) } { \mathrm { d } w } = \frac { \mathrm { d } L } { \mathrm { d } w }
+$$
+
+and therefore it suffices to focus on differentiating the piecewise constant function $f ( \boldsymbol { y } ( \boldsymbol { w } ) )$
+
+If the piecewise constant function at hand was arbitrary, we would be forced to use zero-order gradient estimation techniques such as computing finite differences. These require prohibitively many function evaluations particularly for high-dimensional problems.
+
+However, the function $f ( \boldsymbol { y } ( \boldsymbol { w } ) )$ is a result of a minimization process and it is known that for smooth spaces $Y$ there are techniques for such “differentiation through argmin” (Schmidt & Roth, 2014; Samuel & Tappen, 2009; Foo et al., 2008; Domke, 2012; Amos et al., 2017; Amos & Kolter, 2017). It turns out to be possible to build – with different mathematical tools – a viable discrete analogy. In particular, we can efficiently construct a function $f _ { \lambda } ( w )$ , a continuous interpolation of $f ( y ( w ) )$ , whose gradient we return (see Fig. 2). The hyper-parameter $\lambda > 0$ controls the trade-off between “informativeness of the gradient” and “faithfulness to the original function”.
+
+Before diving into the formalization, we present the final algorithm as listed in Algo. 1. It is simple to implement and the backward pass indeed only runs the solver once on modified input. Providing the justification, however, is not straightforward, and it is the subject of the rest of the section.
+
+<table><tr><td colspan="2">Algorithm1 Forward and Backward Pass</td></tr><tr><td>function FORWARDPASS(ω)</td><td>function BACKWARDPASS( (), λ)</td></tr><tr><td>y := Solver(ω) I y= y(ω)</td><td>load ω and y from forward pass</td></tr><tr><td>save ω and y for backward pass</td><td>w&#x27;:=w+&gt;. 品 (y）</td></tr><tr><td>return y</td><td>Il Calculate perturbed weights</td></tr><tr><td></td><td>yx := Solver(w&#x27;)</td></tr><tr><td></td><td>return Vωfx(ω) := -1[y - yx]</td></tr><tr><td></td><td>ll Gradient of continuous interpolation</td></tr></table>
+
+# 3.1 CONSTRUCTION AND PROPERTIES OF $f _ { \lambda }$
+
+Before we give the exact definition of the function $f _ { \lambda }$ , we formulate several requirements on it. This will help us understand why $f _ { \lambda } ( w )$ is a reasonable replacement for $f ( \boldsymbol { y } ( \boldsymbol { w } ) )$ and, most importantly, why its gradient captures changes in the values of $f$ .
+
+Property A1. For each $\lambda > 0$ , $f _ { \lambda }$ is continuous and piecewise affine.
+
+The second property describes the trade-off induced by changing the value of $\lambda$ . For $\lambda > 0$ , we define sets $\dot { W } _ { \mathrm { e q } } ^ { \lambda }$ and $\dot { W } _ { \mathrm { d i f } } ^ { \lambda }$ as the sets where $f ( \boldsymbol { y } ( \boldsymbol { w } ) )$ and $f _ { \lambda } ( w )$ coincide and where they differ, i.e.
+
+$$
+W _ { \mathrm { e q } } ^ { \lambda } = \left\{ w \in W : f _ { \lambda } ( w ) = f \bigl ( y ( w ) \bigr ) \right\} \quad \mathrm { a n d } \quad W _ { \mathrm { d i f } } ^ { \lambda } = W \setminus W _ { \mathrm { e q } } ^ { \lambda } .
+$$
+
+Property A2. The sets $W _ { \mathrm { d i f } } ^ { \lambda }$ are monotone in $\lambda$ and they vanish as $\lambda  0 ^ { + }$ , i.e.
+
+$$
+W _ { \mathrm { d i f } } ^ { \lambda _ { 1 } } \subseteq W _ { \mathrm { d i f } } ^ { \lambda _ { 2 } } \quad \mathrm { f o r } 0 < \lambda _ { 1 } \leq \lambda _ { 2 } \quad \mathrm { a n d } \quad W _ { \mathrm { d i f } } ^ { \lambda } \to \varnothing \quad \mathrm { a s } \ \lambda \to 0 ^ { + } .
+$$
+
+In other words, Property A2 tells us that $\lambda$ controls the size of the set where $f _ { \lambda }$ deviates from $f$ and where $f _ { \lambda }$ has meaningful gradient. This behaviour of $f _ { \lambda }$ can be seen in Fig. 2.
+
+In the third and final property, we want to capture the interpolation behavior of $f _ { \lambda }$ . For that purpose, we define a $\delta$ -interpolator of $f$ . We say that $g$ , defined on a set $G \subset W$ , is a $\delta$ -interpolator of $f$ between $y _ { 1 }$ and $y _ { 2 } \in Y$ , if
+
+• $g$ is non-constant affine function;   
+• the image $g ( G )$ is an interval with endpoints $f ( y _ { 1 } )$ and $f ( y _ { 2 } )$ ;   
+• $g$ attains the boundary values $f ( y _ { 1 } )$ and $f ( y _ { 2 } )$ at most $\delta$ -far away from where $f ( y ( w ) )$ does. In particular, there is a point $w _ { k } \in G$ for which $g ( w _ { k } ) = f ( y _ { k } )$ and $\mathrm { d i s t } ( w _ { k } , P _ { k } ) \le \delta$ , where $P _ { k } = \{ w \in W : y ( w ) = y _ { k } \}$ , for $k = 1 , 2$ .
+
+In the special case of a 0-interpolator $g$ , the graph of $g$ connects (in a topological sense) two components of the graph of $f ( y ( \dot { w } ) )$ . In the general case, $\delta$ measures displacement of the interpolator (see also Fig. 2 for some examples). This displacement on the one hand loosens the connection to $\dot { f } \left( y ( w ) \right)$ but on the other hand allows for less local interpolation which might be desirable.
+
+Property A3. The function $f _ { \lambda }$ consists of finitely many (possibly incomplete) $\delta$ -interpolators of $f$ on $\hat { W } _ { \mathrm { d i f } } ^ { \lambda }$ where $\delta \leq C \lambda$ for some fixed $C$ . Equivalently, the displacement is linearly controlled by $\lambda$
+
+Intuitively, the consequence of Property A3 is that $f _ { \lambda }$ has reasonable gradients everywhere since it consists of elementary affine interpolators.
+
+For defining the function $f _ { \lambda }$ , we need a solution of a perturbed optimization problem
+
+$$
+y _ { \lambda } ( w ) = { \underset { y \in Y } { \operatorname { a r g m i n } } } \{ \mathbf { c } ( w , y ) + \lambda f ( y ) \} .
+$$
+
+Theorem 1. Let $\lambda > 0$ . The function $f _ { \lambda }$ defined by
+
+$$
+f _ { \lambda } ( w ) = f { \big ( } y _ { \lambda } ( w ) { \big ) } - { \frac { 1 } { \lambda } } { \Big [ } \mathbf { c } { \big ( } w , y ( w ) { \big ) } - \mathbf { c } { \big ( } w , y _ { \lambda } ( w ) { \big ) } { \Big ] }
+$$
+
+satisfies Properties A1, A2, A3.
+
+Let us remark that already the continuity of $f _ { \lambda }$ is not apparent from its definition as the first term $f ( y _ { \lambda } ( w ) )$ is still a piecewise constant function. Proof of this result, along with geometrical description of $f _ { \lambda }$ , can be found in section A.2. Fig. 3 visualizes $f _ { \lambda }$ for different values if $\lambda$ .
+
+Now, since $f _ { \lambda }$ is ensured to be differentiable, we have
+
+$$
+\nabla f _ { \lambda } ( w ) = - \frac { 1 } { \lambda } \Big [ \frac { \mathrm { d } \mathbf { c } } { \mathrm { d } w } \big ( w , y ( w ) \big ) - \frac { \mathrm { d } \mathbf { c } } { \mathrm { d } w } \big ( w , y _ { \lambda } ( w ) \big ) \Big ] = - \frac { 1 } { \lambda } \big [ y ( w ) - y _ { \lambda } ( w ) \big ] .
+$$
+
+The second equality then holds due to (2). We then return $\nabla f _ { \lambda }$ as a loss gradient.
+
+Remark 1. The roots of the method we propose lie in loss-augmented inference. In fact, the update rule from (5) (but not the function $f _ { \lambda }$ or any of its properties) was already proposed in a different context in (Hazan et al., 2010; Song et al., 2016) and was later used in (Lorberbom et al., 2018; Mohapatra et al., 2018). The main difference to our work is that only the case of $\lambda  0 ^ { + }$ is recommended and studied, which in our situation computes the correct but uninformative zero gradient. Our analysis implies that larger values of $\lambda$ are not only sound but even preferable. This will be seen in experiments where we use values $\lambda \approx 1 0 - 2 0$ .
+
+![](images/1d726e1211cf775ed97ca541a5a85a081509a5088d2c2cad5b95f8fee7b5c1a1.jpg)  
+Figure 3: Example $f _ { \lambda }$ for $w \in \mathbb { R } ^ { 2 }$ and $\lambda = 3 , 1 0 , 2 0$ (left to right). As $\lambda$ changes, the interpolation $f _ { \lambda }$ is less faithful to the piecewise constant $f ( \boldsymbol { y } ( \boldsymbol { w } ) )$ but provides reasonable gradient on a larger set.
+
+# 3.2 EFFICIENT COMPUTATION OF $f _ { \lambda }$
+
+Computing $y _ { \lambda }$ in (3) is the only potentially expensive part of evaluating (5). However, the linear interplay of the cost function and the gradient trivially gives a resolution.
+
+Proposition 1. Let $\hat { w } \in W$ be fixed. If we set $\begin{array} { r } { w ^ { \prime } = \hat { w } + \lambda \frac { \mathrm { d } L } { \mathrm { d } y } ( \hat { y } ) } \end{array}$ , we can compute $y _ { \lambda }$ as
+
+$$
+\boldsymbol { y } _ { \lambda } ( \hat { w } ) = \underset { \boldsymbol { y } \in Y } { \arg \operatorname* { m i n } } \mathbf { c } ( w ^ { \prime } , \boldsymbol { y } ) .
+$$
+
+In other words, $y _ { \lambda }$ is the output of calling the solver on input $w ^ { \prime }$ .
+
+# 4 EXPERIMENTS
+
+In this section, we experimentally validate a proof of concept: that architectures containing exact blackbox solvers (with backward pass provided by Algo. 1) can be trained by standard methods.
+
+Table 1: Experiments Overview.   
+
+<table><tr><td>Graph Problem</td><td>Solver</td><td>Solver instance size</td><td>Input format</td></tr><tr><td>Shortest path</td><td>Dijkstra</td><td>up to 900 vertices</td><td>(image) up to 240 × 240</td></tr><tr><td>Min Cost PM</td><td>Blossom V</td><td>up to 1104 edges</td><td>(image) up to 528 × 528</td></tr><tr><td>Traveling Salesman</td><td>Gurobi</td><td>up to 780 edges</td><td>up to 40 images (20 × 40)</td></tr></table>
+
+To that end, we solve three synthetic tasks as listed in Tab. 1. These tasks are designed to mimic practical examples from Section 2 and solving them anticipates a two-stage process: 1) extract suitable features from raw input, 2) solve a combinatorial problem over the features. The dimensionalities of input and of intermediate representations also aim to mirror practical problems and are chosen to be prohibitively large for zero-order gradient estimation methods. Guidelines of setting the hyperparameter $\lambda$ are given in section A.1.
+
+We include the performance of ResNet18 (He et al., 2016) as a sanity check to demonstrate that the constructed datasets are too complex for standard architectures.
+
+Remark 2. The included solvers have very efficient implementations and do not severely impact runtime. All models train in under two hours on a single machine with 1 GPU and no more than 24 utilized CPU cores. Only for the large TSP problems the solver’s runtime dominates.
+
+# 4.1 WARCRAFT SHORTEST PATH
+
+Problem input and output. The training dataset for problem $\operatorname { S P } ( k )$ consists of 10000 examples of randomly generated images of terrain maps from the Warcraft II tileset (Guyomarch, 2017). The maps have an underlying grid of dimension $k \times k$ where each vertex represents a terrain with a fixed cost that is unknown to the network. The shortest (minimum cost) path between top left and bottom right vertices is encoded as an indicator matrix and serves as a label (see also Fig. 4). We consider datasets $\operatorname { S P } ( k )$ for $k \in \{ 1 2 , 1 8 , 2 4 , 3 0 \}$ . More experimental details are provided in section A.3.
+
+![](images/aebd22f7122a987507b5a5df380f095e06acf0115c5b15b52129729f3f12359a.jpg)  
+Figure 4: The $\operatorname { S P } ( k )$ dataset. (a) Each input is a $k \times k$ grid of tiles corresponding to a Warcraft II terrain map, the respective label is a the matrix indicating the shortest path from top left to bottom right. (b) is a different map with correctly predicted shortest path.
+
+Architecture. An image of the terrain map is presented to a convolutional neural network which outputs a $k \times k$ grid of vertex costs. These costs are then the input to the Dijkstra algorithm to compute the predicted shortest path for the respective map. The loss used for computing the gradient update is the Hamming distance between the true shortest path and the predicted shortest path.
+
+Results. Our method learns to predict the shortest paths with high accuracy and generalization capability, whereas the ResNet18 baseline unsurprisingly fails to generalize already for small grid sizes of $k \_ =$ 12. Since the shortest paths in the maps are often nonunique (i.e. there are multiple shortest paths with the same cost), we report the percentage of shortest path predictions that have optimal cost. The results are summarized in Tab. 2.
+
+Table 2: Results for Warcraft shortest path. Reported is the accuracy, i.e. percentage of paths with the optimal costs. Standard deviations are over five restarts.   
+
+<table><tr><td colspan="3">Embedding Dijkstra</td><td colspan="2">ResNet18</td></tr><tr><td>k</td><td>Train %</td><td>Test %</td><td>Train %</td><td>Test %</td></tr><tr><td>12</td><td>99.7±0.0</td><td>96.0± 0.3</td><td>100.0±0.0</td><td>23.0± 0.3</td></tr><tr><td>18</td><td>98.9 ± 0.2</td><td>94.4 ± 0.2</td><td>99.9 ± 0.0</td><td>0.7 ± 0.3</td></tr><tr><td>24</td><td>97.8 ± 0.2</td><td>94.4±0.6</td><td>100.0± 0.0</td><td>0.0±0.0</td></tr><tr><td>30</td><td>97.4± 0.1</td><td>94.0 ± 0.3</td><td>95.6 ± 0.5</td><td>0.0± 0.0</td></tr></table>
+
+# 4.2 GLOBE TRAVELING SALESMAN PROBLEM
+
+Problem input and output. The training dataset for problem $\mathrm { T S P } ( k )$ consists of 10000 examples where the input for each example is a $k$ -element subset of fixed 100 country flags and the label is the shortest traveling salesman tour through the capitals of the corresponding countries. The optimal tour is represented by its adjacency matrix (see also Fig. 5). We consider datasets $\mathrm { T S P } ( k )$ for $k \in \{ 5 , 1 0 , 2 0 , 4 0 \}$ .
+
+![](images/93a1371bc47f5fbc55fc3aa8629e790fdbf4bf0356d5477e55579af56987fedd.jpg)  
+Figure 5: The $\mathrm { T S P } ( k )$ problem. (a) illustrates the dataset. Each input is a sequence of $k$ flags and the corresponding label is the adjacency matrix of the optimal TSP tour around the corresponding capitals. (b) displays the learned locations of 10 country capitals in southeast Asia and Australia, accurately recovering their true position.
+
+Architecture. Each of the $k$ flags is presented to a convolutional network that produces $k$ threedimensional vectors. These vectors are projected onto the unit sphere in $\mathbb { R } ^ { 3 }$ ; a representation of the globe. The TSP solver receives a matrix of pairwise distances of the $k$ computed locations. The loss of the network is the Hamming distance between the true and the predicted TSP adjacency matrix. The architecture is expected to learn the correct representations of the flags (i.e. locations of the respective countries’ capitals on Earth, up to rotations of the sphere). The employed Gurobi solver optimizes a mixed-integer programming formulation of TSP using the cutting plane method (Marchand et al., 2002) for lazy sub-tour elimination.
+
+Results. This architecture not only learns to extract the correct TSP tours but also learns the correct representations. Quantitative evidence is presented in Tab. 3, where we see that the learned locations generalize well and lead to correct TSP tours also on the test set and also on somewhat large instances (note that there are $3 9 ! \approx 1 0 ^ { 4 6 }$ admissible TSP tours for $k = 4 0$ ). The baseline architecture
+
+Table 3: Results for Globe TSP. Reported is the full tour accuracy. Standard deviations are over five restarts.   
+
+<table><tr><td></td><td>Embedding TSP Solver</td><td></td><td>ResNet18</td></tr><tr><td>k</td><td>Train %</td><td>Test %</td><td>Train % Test %</td></tr><tr><td>5</td><td>99.8± 0.0</td><td>99.2 ± 0.1</td><td>100.0± 0.0 1.9 ± 0.6</td></tr><tr><td>10</td><td>99.8 ±0.1</td><td>98.7 ± 0.2 99.0± 0.1</td><td>0.0±0.0</td></tr><tr><td>20</td><td>99.1 ± 0.1</td><td>98.4± 0.4 98.8 ± 0.3</td><td>0.0 ± 0.0</td></tr><tr><td>40</td><td>97.4± 0.2</td><td>96.7± 0.4 96.9 ± 0.3</td><td>0.0±0.0</td></tr></table>
+
+only memorizes the training set. Additionally, we can extract the suggested locations of world capitals and compare them with reality. To that end, we present Fig. 5b, where the learned locations of 10 capitals in Southeast Asia are displayed.
+
+# 4.3 MNIST MIN-COST PERFECT MATCHING
+
+Problem input and output. The training dataset for problem $\mathrm { P M } ( k )$ consists of 10000 examples where the input to each example is a set of $k ^ { 2 }$ digits drawn from the MNIST dataset arranged in a $k \times k$ grid. For computing the label, we consider the underlying $k \times k$ grid graph (without diagonal edges) and solve a MIN-COST-PERFECT-MATCHING problem, where edge weights are given simply by reading the two vertex digits as a two-digit number (we read downwards for vertical edges and from left to right for horizontal edges). The optimal perfect matching (i.e. the label) is encoded by an indicator vector for the subset of the selected edges, see example in Fig. 6.
+
+Architecture. The grid image is the input of a convolutional neural network which outputs a grid of vertex weights. These weights are transformed into edge weights as described above and given to the solver. The loss function is Hamming distance between solver output and the true label.
+
+Results. The architecture containing the solver is capable of good generalizations suggesting that the correct representation is learned. The performance is good even on larger instances and despite the presence of noise in supervision – often there are many optimal matchings. In contrast, the ResNet18 baseline only achieves reasonable performance for the simplest case PM(4). The results are summarized in Tab. 4.
+
+Table 4: Results for MNIST Min-cost perfect matching. Reported is the accuracy of predicting an optimal matching. Standard deviations are over five restarts.   
+
+<table><tr><td></td><td>Embedding Blossom V</td><td></td><td>ResNet18</td></tr><tr><td>k</td><td>Train %</td><td>Test %</td><td>Train % Test %</td></tr><tr><td>4</td><td>99.97 ± 0.01</td><td>98.32 ± 0.24 99.92 ± 0.01</td><td>100.0± 0.0 92.5±0.3 8.3±0.8</td></tr><tr><td>8 16</td><td>99.95 ± 0.04</td><td>99.06± 0.57</td><td>100.0 ± 0.0 100.0± 0.0 0.0±0.0</td></tr><tr><td>24</td><td>99.02 ± 0.84</td><td>92.06 ± 7.97</td><td>96.1 ± 0.5 0.0±0.0</td></tr><tr><td></td><td>95.63 ± 5.49</td><td></td><td></td></tr></table>
+
+# 5 DISCUSSION
+
+We provide a unified mathematically sound algorithm to embed combinatorial algorithms into neural networks. Its practical implementation is straightforward and training succeeds with standard deep learning techniques. The two main branches of future work are: 1) exploring the potential of newly enabled architectures, 2) addressing standing real-world problems. The latter case requires embedding approximate solvers (that are common in practice). This breaks some of our theoretical guarantees but given their strong empirical performance, the fusion might still work well in practice.
+
+![](images/25ffcca54f0937b5c6910ab99eac7f8e6385ee741c8c778f17c9c7232f8f0c99.jpg)  
+Figure 6: Visualization of the PM dataset. (a) shows the case of $\mathrm { P M } ( 4 )$ . Each input is a $4 \times 4$ grid of MNIST digits and the corresponding label is the indicator vector for the edges in the min-cost perfect matching. (b) shows the correct min-cost perfect matching output from the network. The cost of the matching is 348 ( $4 6 + 1 2$ horizontally and $2 7 + 4 5 + 4 0 + 6 7 + 7 8 + 3 3$ vertically).
+
+# ACKNOWLEDGEMENT
+
+We thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting Marin Vlastelica. We acknowledge the support from the German Federal Ministry of Education and Research (BMBF) through the Tbingen AI Center (FKZ: 01IS18039B). Additionally, we would like to thank Paul Swoboda and Alexander Kolesnikov for valuable feedback on an early version of the manuscript.
+
+# REFERENCES
+
+Google’s or-tools, 2019. URL https://developers.google.com/optimization/.
+
+Brandon Amos and J. Zico Kolter. Optnet: Differentiable optimization as a layer in neural networks. arXiv, 1703.00443, 2017. URL http://arxiv.org/abs/1703.00443.
+
+Brandon Amos, Lei Xu, and J Zico Kolter. Input convex neural networks. In 34th International Conference on Machine Learning (ICML’17), pp. 146–155. JMLR, 2017.
+
+Maria-Florina Balcan, Travis Dick, Tuomas Sandholm, and Ellen Vitercik. Learning to branch. In Jennifer G. Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, ICML 2018, Stockholmsmassan, Stockholm, Sweden, July 10-15, 2018 ¨ , volume 80 of Proceedings of Machine Learning Research, pp. 353–362. PMLR, 2018. URL http://proceedings.mlr.press/v80/balcan18a.html.
+
+Mislav Balunovic, Pavol Bielik, and Martin Vechev. Learning to solve SMT formulas. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 10317–10328. Curran Associates, Inc., 2018.
+
+Peter Battaglia, Jessica Blake Chandler Hamrick, Victor Bapst, Alvaro Sanchez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, Caglar Gulcehre, Francis Song, Andy Ballard, Justin Gilmer, George E. Dahl, Ashish Vaswani, Kelsey Allen, Charles Nash, Victoria Jayne Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matt Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. Relational inductive biases, deep learning, and graph networks. arXiv, abs/1806.01261, 2018. URL http://arxiv.org/abs/1806.01261.
+
+Irwan Bello, Hieu Pham, Quoc V. Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. In 5th International Conference on Learning Representations, ICLR 2017, Workshop Track Proceedings, 2017. URL http://openreview.net/forum? id=Bk9mxlSFx.
+
+L. Chen, G. Papandreou, I. Kokkinos, K. Murphy, and A. L. Yuille. DeepLab: Semantic image segmentation with deep convolutional nets, atrous convolution, and fully connected CRFs. IEEE Transactions on Pattern Analysis and Machine Intelligence, 40(04):834–848, 2018.
+
+Liang-Chieh Chen, Alexander G. Schwing, Alan L. Yuille, and Raquel Urtasun. Learning deep structured models. In Proceedings of the 32nd International Conference on International Conference on Machine Learning, ICML’15, pp. 1785–1794. JMLR, 2015.
+
+Emir Demirovic, Peter J. Stuckey, James Bailey, Jeffrey Chan, Christopher Leckie, Kotagiri Ramamohanarao, and Tias Guns. Predict+optimise with ranking objectives: Exhaustively learning linear functions. In Sarit Kraus (ed.), Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019, Macao, China, August 10-16, 2019, pp. 1078–1085. ijcai.org, 2019. doi: 10.24963/ijcai.2019/151. URL https://doi.org/10.24963/ijcai.2019/151.
+
+Michel Deudon, Pierre Cournut, Alexandre Lacoste, Yossiri Adulyasak, and Louis-Martin Rousseau. Learning heuristics for the tsp by policy gradient. In Willem-Jan van Hoeve (ed.), Proc. of Intl. Conf. on Integration of Constraint Programming, Artificial Intelligence, and Operations Research, pp. 170–181. Springer, 2018.
+
+E. W. Dijkstra. A note on two problems in connexion with graphs. Numer. Math., 1(1):269–271, December 1959. doi: 10.1007/BF01386390.
+
+Justin Domke. Generic methods for optimization-based modeling. In Artificial Intelligence and Statistics, pp. 318–326, 2012.
+
+Jack Edmonds. Paths, trees, and flowers. Canad. J. Math., 17:449–467, 1965. URL www.cs. berkeley.edu/∼christos/classics/edmonds.ps.
+
+Adam N. Elmachtoub and Paul Grigas. Smart ”predict, then optimize”. ArXiv, abs/1710.08005, 2017.
+
+Aaron Ferber, Bryan Wilder, Bistra Dilkina, and Milind Tambe. Mipaal: Mixed integer program as a layer. CoRR, abs/1907.05912, 2019. URL http://arxiv.org/abs/1907.05912.
+
+Chuan-sheng Foo, Chuong B Do, and Andrew Y Ng. Efficient multiple hyperparameter learning for log-linear models. In Advances in neural information processing systems, pp. 377–384, 2008.
+
+Maxime Gasse, Didier Chetelat, Nicola Ferroni, Laurent Charlin, and Andrea Lodi. Exact combina- ´ torial optimization with graph convolutional neural networks. arXiv, abs/1906.01629, 2019. URL http://arxiv.org/abs/1906.01629.
+
+John C. Gower and Garmt B. Dijksterhuis. Procrustes problems, volume 30 of Oxford Statistical Science Series. Oxford University Press, Oxford, UK, January 2004.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. arXiv, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwinska, Sergio G ´ omez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, ´ Adria Puigdom \` enech Badia, Karl Moritz Hermann, Yori Zwols, Georg Ostrovski, Adam Cain, \` Helen King, Christopher Summerfield, Phil Blunsom, Koray Kavukcuoglu, and Demis Hassabis. Hybrid computing using a neural network with dynamic external memory. Nature, 538(7626): 471–476, October 2016.
+
+LLC Gurobi Optimization. Gurobi optimizer reference manual, 2019. URL http://www.gurobi.com.
+
+Jean Guyomarch. Warcraft ii open-source map editor, 2017. URL http://github.com/war2/war2edit.
+
+Tamir Hazan, Joseph Keshet, and David A. McAllester. Direct loss minimization for structured prediction. In Advances in Neural Information Processing Systems 23, pp. 1594–1602. Curran Associates, Inc., 2010.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.
+
+Elias B. Khalil, Pierre Le Bodic, Le Song, George Nemhauser, and Bistra Dilkina. Learning to branch in mixed integer programming. In Proceedings of the Thirtieth AAAI Conference on Artificial Intelligence, AAAI16, pp. 724731. AAAI Press, 2016.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization, 2014. cite arxiv:1412.6980Comment: Published as a conference paper at the 3rd International Conference for Learning Representations, San Diego, 2015.
+
+Patrick Knobelreiter, Christian Reinbacher, Alexander Shekhovtsov, and Thomas Pock. End-to-end¨ training of hybrid cnn-crf models for stereo. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’17), July 2017.
+
+Vladimir Kolmogorov. Blossom V: a new implementation of a minimum cost perfect matching algorithm. Mathematical Programming Computation, 1(1):43–67, Jul 2009. doi: 10.1007/ s12532-009-0002-8. URL http://pub.ist.ac.at/∼vnk/software.html.
+
+Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations (ICLR’19), 2019. URL http://openreview. net/forum?id=ByxBFsRqYm.
+
+Yujia Li, Richard Zemel, Marc Brockschmidt, and Daniel Tarlow. Gated graph sequence neural networks. In International Conference on Learning Representations (ICLR’16), 2016. URL http://arxiv.org/abs/1511.05493.
+
+Zhuwen Li, Qifeng Chen, and Vladlen Koltun. Combinatorial optimization with graph convolutional networks and guided tree search. In Advances in Neural Information Processing Systems, NeurIPS’18, pp. 537–546, USA, 2018. Curran Associates Inc.
+
+Ziwei Liu, Xiaoxiao Li, Ping Luo, Chen-Change Loy, and Xiaoou Tang. Semantic image segmentation via deep parsing network. In IEEE International Conference on Computer Vision, ICCV’15, pp. 1377–1385. IEEE Computer Society, 2015. doi: 10.1109/ICCV.2015.162.
+
+Guy Lorberbom, Andreea Gane, Tommi S. Jaakkola, and Tamir Hazan. Direct optimization through arg max for discrete variational auto-encoder. arXiv, abs/1806.02867, 2018. URL http://arxiv. org/abs/1806.02867.
+
+Jaynta Mandi, Emir Demirovic, Peter J. Stuckey, and Tias Guns. Smart predict-and-optimize for hard combinatorial optimization problems. CoRR, abs/1911.10092, 2019. URL http://arxiv.org/ abs/1911.10092.
+
+Hugues Marchand, Alexander Martin, Robert Weismantel, and Laurence Wolsey. Cutting planes in integer and mixed integer programming. Discrete Appl. Math., 123(1-3):397–446, November 2002. doi: 10.1016/S0166-218X(01)00348-1.
+
+Dmitrii Marin, Meng Tang, Ismail Ben Ayed, and Yuri Boykov. Beyond gradient descent for regularized segmentation losses. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’19), June 2019.
+
+Shakir Mohamed, Mihaela Rosca, Michael Figurnov, and Andriy Mnih. Monte carlo gradient estimation in machine learning. arXiv, abs/1906.10652, 2019. URL http://arxiv.org/abs/1906.10652.
+
+Pritish Mohapatra, Michal Rol´ınek, C.V. Jawahar, Vladimir Kolmogorov, and M. Pawan Kumar. Efficient optimization for rank-based loss functions. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’18), June 2018.
+
+MohammadReza Nazari, Afshin Oroojlooy, Lawrence Snyder, and Martin Takac. Reinforcement learning for solving the vehicle routing problem. In S. Bengio, H. Wallach, H. Larochelle, K. Grauman, N. Cesa-Bianchi, and R. Garnett (eds.), Advances in Neural Information Processing Systems 31, pp. 9839–9849. Curran Associates, Inc., 2018. URL http://papers.nips.cc/paper/ 8190-reinforcement-learning-for-solving-the-vehicle-routing-problem.pdf.
+
+Vlad Niculae, Andre Martins, Mathieu Blondel, and Claire Cardie. SparseMAP: Differentiable sparse structured inference. In Jennifer Dy and Andreas Krause (eds.), Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 3799–3808, Stockholmsmssan, Stockholm Sweden, 10–15 Jul 2018. PMLR. URL http://proceedings.mlr.press/v80/niculae18a.html.
+
+Despoina Paschalidou, Ali Osman Ulusoy, Carolin Schmitt, Luc Gool, and Andreas Geiger. Raynet: Learning volumetric 3d reconstruction with ray potentials. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’18), 2018.
+
+Leonid Pishchulin, Eldar Insafutdinov, Siyu Tang, Bjorn Andres, Mykhaylo Andriluka, Peter Gehler, ¨ and Bernt Schiele. Deepcut: Joint subset partition and labeling for multi person pose estimation. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’16), pp. 4929–4937. IEEE, 2016.
+
+Alec Radford, Luke Metz, and Soumith Chintala. Unsupervised representation learning with deep convolutional generative adversarial networks, 2015. URL http://arxiv.org/abs/1511.06434.
+
+Prasad Raghavendra. Optimal algorithms and inapproximability results for every CSP? In Proceedings of the 40th Annual ACM Symposium on Theory of Computing, STOC ’08, pp. 245–254, New York, NY, USA, 2008. ACM. doi: 10.1145/1374376.1374414.
+
+Kegan GG Samuel and Marshall F Tappen. Learning optimized map estimates in continuouslyvalued mrf models. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’09), pp. 477–484, 2009.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. Trans. Neur. Netw., 20(1):61–80, January 2009. ISSN 1045- 9227. doi: 10.1109/TNN.2008.2005605.
+
+Uwe Schmidt and Stefan Roth. Shrinkage fields for effective image restoration. In IEEE Conference on Computer Vision and Pattern Recognition (CVPR’14), pp. 2774–2781, 2014.
+
+Samuel Schulter, Paul Vernaza, Wongun Choi, and Manmohan Krishna Chandraker. Deep network flow for multi-object tracking. IEEE Conference on Computer Vision and Pattern Recognition (CVPR’17), pp. 2730–2739, 2017.
+
+Daniel Selsam and Nikolaj Bjørner. Guiding high-performance SAT solvers with Unsat-Core predictions. In Mikola´s Janota and In ˇ es Lynce (eds.), ˆ Theory and Applications of Satisfiability Testing – SAT 2019, pp. 336–353. Springer International Publishing, 2019.
+
+Daniel Selsam, Matthew Lamm, Benedikt Bunz, Percy Liang, Leonardo de Moura, and David L. ¨ Dill. Learning a SAT solver from single-bit supervision. In International Conference on Learning Representations (ICLR’19), 2019. URL http://openreview.net/forum?id=HJMC iA5tm.
+
+Jie Song, Bjoern Andres, Michael Black, Otmar Hilliges, and Siyu Tang. End-to-end learning for graph decomposition. arXiv, 1812.09737, 2018. URL http://arxiv.org/abs/1812.09737.
+
+Yang Song, Alexander Schwing, Richard, and Raquel Urtasun. Training deep neural networks via direct loss minimization. In 33rd International Conference on Machine Learning (ICML), volume 48 of Proceedings of Machine Learning Research, pp. 2169–2177. PMLR, 2016.
+
+Sainbayar Sukhbaatar, Arthur Szlam, Jason Weston, and Rob Fergus. End-to-end memory networks. In Advances in Neural Information Processing Systems 28 (NIPS), pp. 2440–2448. Curran Associates, Inc., 2015.
+
+Johan Thapper and Stanislav Zivn ˇ y. The limits of SDP relaxations for general-valued CSPs. In ´ 32nd Annual ACM/IEEE Symposium on Logic in Computer Science, LICS ’17, pp. 27:1–27:12, Piscataway, NJ, USA, 2017. IEEE Press.
+
+Jonathan J Tompson, Arjun Jain, Yann LeCun, and Christoph Bregler. Joint training of a convolutional network and a graphical model for human pose estimation. In Advances in Neural Information Processing Systems 27 (NIPS’14), pp. 1799–1807. Curran Associates, Inc., 2014.
+
+Sebastian Tschiatschek, Aytunc Sahin, and Andreas Krause. Differentiable submodular maximization. In Proc. International Joint Conference on Artificial Intelligence (IJCAI), July 2018.
+
+Ioannis Tsochantaridis, Thorsten Joachims, Thomas Hofmann, and Yasemin Altun. Large margin methods for structured and interdependent output variables. J. Mach. Learn. Res., 6:1453–1484, 2005.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems 28 (NIPS’15), pp. 2692–2700. Curran Associates, Inc., 2015.
+
+Po-Wei Wang, Priya L. Donti, Bryan Wilder, and Zico Kolter. SATNet: Bridging deep learning and logical reasoning using a differentiable satisfiability solver. arXiv, 1905.12149, 2019. URL http://arxiv.org/abs/1905.12149.
+
+Bryan Wilder, Eric Ewing, Bistra Dilkina, and Milind Tambe. End to end learning and optimization on graphs. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d AlcheBuc, E. Fox, and R. Garnett (eds.), Advances in Neural Information Processing Systems 32, pp. 4674–4685. Curran Associates, Inc., 2019. URL http://papers.nips.cc/paper/ 8715-end-to-end-learning-and-optimization-on-graphs.pdf.
+
+Mang Ye, Andy J. Ma, Liang Zheng, Jiawei Li, and Pong C. Yuen. Dynamic label graph matching for unsupervised video re-identification. In IEEE International Conference on Computer Vision (ICCV’17). IEEE Computer Society, Oct 2017.
+
+Shuai Zheng, Sadeep Jayasumana, Bernardino Romera-Paredes, Vibhav Vineet, Zhizhong Su, Dalong Du, Chang Huang, and Philip H. S. Torr. Conditional random fields as recurrent neural networks. In IEEE International Conference on Computer Vision (ICCV’15), pp. 1529–1537. IEEE Computer Society, 2015.
+
+# A APPENDIX
+
+# A.1 GUIDELINES FOR SETTING THE VALUES OF $\lambda$ .
+
+In practice, $\lambda$ has to be chosen appropriately, but we found its exact choice uncritical (no precise tuning was required). Nevertheless, note that $\lambda$ should cause a noticeable disruption in the optimization problem from equation (3), otherwise it is too likely that $y ( w ) = y _ { \lambda } ( w )$ resulting in a zero gradient. In other words, $\lambda$ should roughly be of the magnitude that brings the two terms in the definition of $w ^ { \prime }$ in Prop. 1 to the same order:
+
+$$
+\lambda \approx \frac { \left. w \right. } { \left. \frac { \mathrm { d } L } { \mathrm { d } y } \right. }
+$$
+
+where $\langle \cdot \rangle$ stands for the average. This again justifies that $\lambda$ is a true hyperparameter and that there is no reason to expect values around $\lambda \bar {  } 0 ^ { \bar { + } }$ .
+
+# A.2 PROOFS
+
+Proof of Proposition 1. Let us write $L = L ( \hat { y } )$ and $\begin{array} { r } { \nabla L = \frac { \mathrm { d } L } { \mathrm { d } y } ( \hat { y } ) } \end{array}$ , for brevity. Thanks to the linearity of $\mathbf { c }$ and the definition of $f$ , we have
+
+$$
+\mathbf { c } ( \hat { w } , y ) + \lambda f ( y ) = \hat { w } y + \lambda \big ( L + \nabla L ( y - \hat { y } ) \big ) = ( \hat { w } + \lambda \nabla L ) y + \lambda L - \lambda \nabla L \hat { y } = \mathbf { c } ( w ^ { \prime } , y ) + \mathbf { c } _ { 0 } ,
+$$
+
+where $\mathbf { c } _ { 0 } = \lambda L - \lambda \nabla L \hat { y }$ and $w ^ { \prime } = \hat { w } + \lambda \nabla L$ as desired. The conclusion about the points of minima then follows.
+
+Before we prove Theorem 1, we make some preliminary observations. To start with, due to the definition of the solver, we have the fundamental inequality
+
+$$
+\mathbf { c } ( w , y ) \geq \mathbf { c } { \big ( } w , y ( w ) { \big ) } \quad { \mathrm { f o r ~ e v e r y ~ } } w \in W { \mathrm { ~ a n d ~ } } y \in Y .
+$$
+
+Observation 1. The function $w \mapsto \mathbf { c } \big ( w , y ( w ) \big )$ is continuous and piecewise linear.
+
+Proof. Since c’s are linear and distinct, $\mathbf { c } ( w , y ( w ) )$ , as their pointwise minimum, has the desired properties. □
+
+Analogous fundamental inequality
+
+$\mathbf { c } ( w , y ) + \lambda f ( y ) \geq \mathbf { c } { \big ( } w , y _ { \lambda } ( w ) { \big ) } + \lambda f { \big ( } y _ { \lambda } ( w ) { \big ) } \quad { \mathrm { f o r ~ e } }$ very $w \in W$ and $y \in Y$
+
+follows from the definition of the solution to the optimization problem (3).
+
+A counterpart of Observation 1 reads as follows.
+
+Observation 2. The function $w \mapsto { \bf c } \big ( w , y _ { \lambda } ( w ) \big ) + \lambda f \big ( y _ { \lambda } ( w ) \big )$ is continuous and piecewise affine.
+
+Proof. The function under inspection is a pointwise minimum of distinct affine functions $w \mapsto$ $\mathbf { c } ( w , y ) + \lambda f ( y )$ as $y$ ranges $Y$ .
+
+As a consequence of above-mentioned fundamental inequalities, we obtain the following two-sided estimates on $f _ { \lambda }$ .
+
+Observation 3. The following inequalities hold for $w \in W$
+
+$$
+f \bigl ( y _ { \lambda } ( w ) \bigr ) \leq f _ { \lambda } ( w ) \leq f \bigl ( y ( w ) \bigr ) .
+$$
+
+Proof. Inequality (6) implies that $\mathbf { c } \big ( w , y ( w ) \big ) - \mathbf { c } \big ( w , y _ { \lambda } ( w ) \big ) \ \leq \ 0$ and the first inequality then follows simply from the definition of $f _ { \lambda }$ . As for the second one, it suffices to apply (7) to $y =$ $y ( w )$ .
+
+Now, let us introduce few notions that will be useful later in the proofs. For a fixed $\lambda , W$ partitions into maximal connected sets $P$ on which $y _ { \lambda } ( w )$ is constant (see Fig. 7). We denote this collection of sets by ${ \mathcal { W } } _ { \lambda }$ and set $\mathcal { W } = \mathcal { W } _ { 0 }$ .
+
+For $\lambda \in \mathbb { R }$ and $y _ { 1 } \ne y _ { 2 } \in Y$ , we denote
+
+$$
+F _ { \lambda } ( y _ { 1 } , y _ { 2 } ) = \big \{ w \in W : c ( w , y _ { 1 } ) + \lambda f ( y _ { 1 } ) = c ( w , y _ { 2 } ) + \lambda f ( y _ { 2 } ) \big \} .
+$$
+
+We write $F ( y _ { 1 } , y _ { 2 } ) = F _ { 0 } ( y _ { 1 } , y _ { 2 } )$ , for brevity. For technical reasons, we also allow negative values of $\lambda$ here.
+
+(a) The situation for $\lambda \ = \ 0$ . We can see the polytope $P$ on which $y ( w )$ attains $y _ { 1 } \in Y$ . The boundary of $P$ is composed of segments of lines $F ( y _ { 1 } , y _ { k } )$ for $k = 2 , \ldots , 5$ .
+
+![](images/232f340aaca3efe65b2229d5e3ec72dad55d58b162a7c9e17e73c6dadfb41045.jpg)  
+(b) The same situation is captured for some relatively small $\lambda > 0$ . Each line $F _ { \lambda } ( y _ { 1 } , y _ { k } )$ is parallel to its corresponding $F ( y _ { 1 } , y _ { k } )$ and encompasses a convex polytope in ${ \mathcal { W } } _ { \lambda }$ .   
+Figure 7: The family ${ \mathcal { W } } _ { \lambda }$ of all maximal connected sets $P$ on which $y _ { \lambda }$ is constant.
+
+Note, that if $W \ : = \ : \mathbb { R } ^ { N }$ , then $F _ { \lambda }$ is a hyperplane since c’s are linear. In general, $W$ may just be a proper subset of $\mathbb { R } ^ { N }$ and, in that case, $F _ { \lambda }$ is just the restriction of a hyperplane onto $W$ . Consequently, it may happen that $F _ { \lambda } ( y _ { 1 } , y _ { 2 } )$ will be empty for some pair of $y _ { 1 } , y _ { 2 }$ and some $\lambda \in \mathbb { R }$ . To emphasize this fact, we say “hyperplane in $W ^ { \prime \prime }$ . Analogous considerations should be taken into account for all other linear objects. The note “in $W ^ { \prime \prime }$ stands for the intersection of these linear object with the set $W$ .
+
+Observation 4. Let $P \in \mathcal { W } _ { \lambda }$ and let $y _ { \lambda } ( w ) = y$ for $w \in P$ . Then $P$ is a convex polytope in $W$ , where the facets consist of parts of finitely many hyperplanes $F _ { \lambda } ( y , y _ { k } )$ in $W$ for some $\{ y _ { k } \} \subset Y$ .
+
+Proof. Assume that $W = \mathbb { R } ^ { N }$ . The values of $y _ { \lambda }$ may only change on hyperplanes of the form $F _ { \lambda } ( y , y ^ { \prime } )$ for some $y ^ { \prime } \in Y$ . Then $P$ is an intersection of corresponding half-spaces and therefore $P$ is a convex polytope. If $W$ is a proper subset of $\mathbb { R } ^ { N }$ the claim follows by intersecting all the objects with $W$ . □
+
+Observation 5. Let $y _ { 1 } , y _ { 2 } \in Y$ be distinct. If nonempty, the hyperplanes $F ( y _ { 1 } , y _ { 2 } )$ and $F _ { \lambda } ( y _ { 1 } , y _ { 2 } )$ are parallel and their distance is equal to $| \lambda | K ( y _ { 1 } , y _ { 2 } )$ , where
+
+$$
+K ( y _ { 1 } , y _ { 2 } ) = { \frac { | f ( y _ { 1 } ) - f ( y _ { 2 } ) | } { \| y _ { 1 } - y _ { 2 } \| } } .
+$$
+
+Proof. If we define a function $c ( w ) = \mathbf { c } ( w , y _ { 1 } ) - \mathbf { c } ( w , y _ { 2 } ) = w ( y _ { 1 } - y _ { 2 } )$ and a constant $C =$ $f ( y _ { 2 } ) - f ( y _ { 1 } )$ , then our objects rewrite to
+
+$$
+F ( y _ { 1 } , y _ { 2 } ) = \{ w \in W : c ( w ) = 0 \} \quad { \mathrm { a n d } } \quad F _ { \lambda } ( y _ { 1 } , y _ { 2 } ) = \{ w \in W : c ( w ) = \lambda C \} .
+$$
+
+Since $c$ is linear, these sets are parallel and $F ( y _ { 1 } , y _ { 2 } )$ intersects the origin. Thus, the required distance is the distance of the hyperplane $F _ { \lambda } ( y _ { 1 } , y _ { 2 } )$ from the origin, which equals to $| \lambda C | / \bar { | | } y _ { 1 } -$ $y _ { 2 } \|$ . □
+
+As the set $Y$ is finite, there is a uniform upper bound $K$ on all values of $K ( y _ { 1 } , y _ { 2 } )$ . Namely
+
+$$
+K = \operatorname* { m a x } _ { \boldsymbol { y } _ { 1 } , \boldsymbol { y } _ { 2 } \in \boldsymbol { Y } \atop \boldsymbol { y } _ { 1 } \neq \boldsymbol { y } _ { 2 } } K ( \boldsymbol { y } _ { 1 } , \boldsymbol { y } _ { 2 } ) .
+$$
+
+# A.2.1 PROOF OF THEOREM 1
+
+Proof of Property A1. Now, Property A1 follows, since
+
+$$
+f _ { \lambda } ( w ) = { \frac { 1 } { \lambda } } { \Big [ } \mathbf { c } { \big ( } w , y _ { \lambda } ( w ) { \big ) } + \lambda f { \big ( } y _ { \lambda } ( w ) { \big ) } { \Big ] } - { \frac { 1 } { \lambda } } \mathbf { c } { \big ( } w , y ( w ) { \big ) }
+$$
+
+and $f _ { \lambda }$ is a difference of continuous and piecewise affine functions.
+
+Proof of Property A2. Let $0 < \lambda _ { 1 } \leq \lambda _ { 2 }$ be given. We show that $W _ { \mathsf { e q } } ^ { \lambda _ { 2 } } \subseteq W _ { \mathsf { e q } } ^ { \lambda _ { 1 } }$ which is the same as showing $W _ { \mathrm { d i f } } ^ { \lambda _ { 1 } } \subseteq W _ { \mathrm { d i f } } ^ { \lambda _ { 2 } }$ . Assume that $w \in W _ { \mathrm { e q } } ^ { \lambda _ { 2 } }$ , that is, by the definition of $W _ { \mathrm { e q } } ^ { \lambda _ { 2 } }$ and $f _ { \lambda }$ ,
+
+$$
+\mathbf { c } \bigl ( w , y ( w ) \bigr ) + \lambda _ { 2 } f \bigl ( y ( w ) \bigr ) = \mathbf { c } ( w , y _ { 2 } ) + \lambda _ { 2 } f \bigl ( y _ { 2 } \bigr ) ,
+$$
+
+in which we denoted $y _ { 2 } = y _ { \lambda _ { 2 } } ( w )$ . Our goal is to show that
+
+$$
+\mathbf { c } \bigl ( w , y ( w ) \bigr ) + \lambda _ { 1 } f \bigl ( y ( w ) \bigr ) = \mathbf { c } ( w , y _ { 1 } ) + \lambda _ { 1 } f \bigl ( y _ { 1 } \bigr ) ,
+$$
+
+where $y _ { 1 } = y _ { \lambda _ { 1 } } ( w )$ as this equality then guarantees that $w \in W _ { \mathrm { e q } } ^ { \lambda _ { 1 } }$ . Observe that (7) applied to $\lambda = \lambda _ { 1 }$ and $y = y ( w )$ , yields the inequality $\because$ in (10).
+
+Let us show the reversed inequality. By Observation 3 applied to $\lambda = \lambda _ { 1 }$ , we have
+
+$$
+f ( y ( w ) ) \geq f ( y _ { 1 } ) .
+$$
+
+We now use (7) with $\lambda = \lambda _ { 2 }$ and $y = y _ { 1 }$ , followed by equality (9) to obtain
+
+$$
+\begin{array} { r l } & { \mathbf c ( w , y _ { 1 } ) + \lambda _ { 1 } f ( y _ { 1 } ) = \mathbf c ( w , y _ { 1 } ) + \lambda _ { 2 } f ( y _ { 1 } ) + ( \lambda _ { 1 } - \lambda _ { 2 } ) f ( y _ { 1 } ) } \\ & { \qquad \geq \mathbf c ( w , y _ { 2 } ) + \lambda _ { 2 } f ( y _ { 2 } ) + ( \lambda _ { 1 } - \lambda _ { 2 } ) f ( y _ { 1 } ) } \\ & { \qquad = \mathbf c ( w , y ( w ) ) + \lambda _ { 2 } f \big ( y ( w ) \big ) + ( \lambda _ { 1 } - \lambda _ { 2 } ) f ( y _ { 1 } ) } \\ & { \qquad = \mathbf c \big ( w , y ( w ) \big ) + \lambda _ { 1 } f \big ( y ( w ) \big ) + ( \lambda _ { 2 } - \lambda _ { 1 } ) \big [ f \big ( y ( w ) \big ) - f ( y _ { 1 } ) \big ] } \\ & { \qquad \geq \mathbf c \big ( w , y ( w ) \big ) + \lambda _ { 1 } f \big ( y ( w ) \big ) } \end{array}
+$$
+
+where the last inequality holds due to (11).
+
+Next, we have to show that $W _ { \mathrm { d i f } } ^ { \lambda } \to \emptyset$ as $\lambda  0 ^ { + }$ , i.e. that for almost every $w \in W$ , there is a $\lambda > 0$ such that $w \not \in W _ { \mathrm { d i f } } ^ { \lambda }$ . To this end, let $w \in W$ be given. We can assume that $y ( w )$ is a unique solution of solver (1), since two solutions, say $y _ { 1 }$ and $y _ { 2 }$ , coincide only on the hyperplane $F ( y _ { 1 } , y _ { 2 } )$ in $W$ , which is of measure zero. Thus, since $Y$ is finite, the constant
+
+$$
+c = \operatorname* { m i n } _ { y \in Y \atop y \neq y ( w ) } \left\{ \mathbf { c } ( w , y ) - \mathbf { c } \big ( w , y ( w ) \big ) \right\}
+$$
+
+is positive. Denote
+
+$$
+d = \operatorname* { m a x } _ { y \in Y } \{ f { \big ( } y ( w ) { \big ) } - f ( y ) \} .
+$$
+
+If $d > 0$ , set $\lambda < c / d$ . Then, for every $y \in Y$ such that $f \left( y ( w ) \right) > f ( y )$ , we have
+
+$$
+\lambda < \frac { \mathbf { c } ( w , y ) - \mathbf { c } ( w , y ( w ) ) } { f \big ( y ( w ) \big ) - f ( y ) }
+$$
+
+which rewrites
+
+$$
+\mathbf { c } \big ( w , y ( w ) \big ) + \lambda f \big ( y ( w ) \big ) < \mathbf { c } ( w , y ) + \lambda f ( y ) .
+$$
+
+For the remaining ’s, (13) holds trivially for every $\lambda > 0$ . Therefore, $y ( w )$ is a solution of the minimization problem (3), whence $y _ { \lambda } ( w ) = y ( w )$ . This shows that $w \in W _ { \mathrm { e q } } ^ { \lambda }$ as we wished. If $d = 0$ , then $f \bigl ( y ( w ) \bigr ) \leq f ( y )$ for every $y \in Y$ and (13) follows again. □
+
+Proof of Property A3. Let $y _ { 1 } \ne y _ { 2 } \in Y$ be given. We show that on the component of the set
+
+$$
+\{ w \in W : y ( w ) = y _ { 1 } \mathrm { a n d } y _ { \lambda } ( w ) = y _ { 2 } \}
+$$
+
+the function $f _ { \lambda }$ agrees with a $\delta$ -interpolator, where $\delta \leq C \lambda$ and $C > 0$ is an absolute constant. The claim follows as there are only finitely many sets and their components of the form (14) in $W _ { \mathrm { d i f } } ^ { \lambda }$ .
+
+Let us set
+
+$$
+h ( w ) = \mathbf { c } ( w , y _ { 1 } ) - \mathbf { c } ( w , y _ { 2 } ) \quad { \mathrm { f o r ~ } } w \in W
+$$
+
+and
+
+$$
+g ( w ) = f ( y _ { 2 } ) - { \frac { 1 } { \lambda } } h ( w ) .
+$$
+
+The condition on c tells us that $h$ is a non-constant affine function. It follows by the definition of $F ( y _ { 1 } , y _ { 2 } )$ and $F _ { \lambda } ( y _ { 1 } , y _ { 2 } )$ that
+
+$$
+h ( w ) = 0 \quad { \mathrm { i f ~ a n d ~ o n l y ~ i f } } \quad w \in F ( y _ { 1 } , y _ { 2 } )
+$$
+
+and
+
+$$
+h ( w ) = \lambda { \big ( } f ( y _ { 2 } ) - f ( y _ { 1 } ) { \big ) } \quad { \mathrm { i f ~ a n d ~ o n l y ~ i f } } \quad w \in F _ { \lambda } ( y _ { 1 } , y _ { 2 } ) .
+$$
+
+By Observation 5, the sets $F$ and $F _ { \lambda }$ are parallel hyperplanes. Denote by $G$ the nonempty intersection of their corresponding half-spaces in $W$ . We show that $g$ is a $\delta$ -interpolator of $f$ on $G$ between $y _ { 1 }$ and $y _ { 2 }$ , with $\delta$ being linearly controlled by $\lambda$ .
+
+We have already observed that $g$ is the affine function ranging from $f ( y _ { 1 } ) - \mathbf { o n }$ the set $F _ { \lambda } ( y _ { 1 } , y _ { 2 } ) -$ to $f ( y _ { 2 } )$ – on the set $F ( y _ { 1 } , y _ { 2 } )$ . It remains to show that $g$ attains both the values $f ( y _ { 1 } )$ and $f ( y _ { 2 } )$ at most $\delta$ -far from the sets $P _ { 1 }$ and $P _ { 2 }$ , respectively, where $P _ { k } \in \mathcal { W }$ denotes a component of the set $\{ w \in W : y ( w ) = y _ { k } \}$ , $k = 1 , 2$ .
+
+Consider $y _ { 1 }$ first. By Observation 4, there are $z _ { 1 } , \dotsc , z _ { \ell } \in Y$ , such that facets of $P _ { 1 }$ are parts of hyperplanes $F ( y _ { 1 } , z _ { 1 } ) , \dots , F ( y _ { 1 } , z _ { \ell } )$ in $W$ . Each of them separates $W$ into two half-spaces, say $W _ { k } ^ { + }$ and $W _ { k } ^ { - }$ , where $W _ { k } ^ { - }$ is the half-space which contains $P _ { 1 }$ and $W _ { k } ^ { + }$ is the other one. Let us denote
+
+$$
+c _ { k } ( w ) = \mathbf { c } ( w , y _ { 1 } ) - \mathbf { c } ( w , z _ { k } ) \quad { \mathrm { f o r ~ } } w \in W { \mathrm { ~ a n d ~ } } k = 1 , \ldots , \ell .
+$$
+
+Every $c _ { k }$ is a non-zero linear function which is negative on $W _ { k } ^ { - }$ and positive on $W _ { k } ^ { + }$ . By the definition of $y _ { 1 }$ , we have
+
+$$
+\begin{array} { r } { \mathbf { c } ( w , y _ { 1 } ) + \lambda f ( y _ { 1 } ) \leq \mathbf { c } ( w , z _ { k } ) + \lambda f ( z _ { k } ) \quad \mathrm { f o r } w \in P _ { 1 } \mathrm { a n d f o r } k = 1 , \dots , \ell , } \end{array}
+$$
+
+that is
+
+$$
+c _ { k } ( w ) \leq \lambda { \big ( } f ( z _ { k } ) - f ( y _ { 1 } ) { \big ) } \quad { \mathrm { f o r ~ } } w \in P _ { 1 } { \mathrm { ~ a n d ~ f o r ~ } } k = 1 , \ldots , \ell .
+$$
+
+(a) The facets of $P _ { 1 }$ consist of parts of hyperplanes $F ( y _ { 1 } , z _ { k } )$ in $W$ . Each facet $F ( y _ { 1 } , z _ { k } )$ has its corresponding shifts $F _ { \lambda }$ and $F _ { - \lambda }$ , from which only one intersects $P$ . The polytope $P _ { 1 } ^ { \lambda }$ is then bounded by those outer shifts.
+
+![](images/0c295faf8067eef2fbe1620db532f98c27c070605735905923b255494d4de8be.jpg)  
+(b) The interpolator $g$ attains the value $f ( y _ { 1 } )$ on a part of $F _ { \lambda } ( y _ { 1 } , y _ { 2 } ) - \mathbf { a }$ border of the domain $G$ . The value $f ( y _ { 2 } )$ is attained on a part of $F ( y _ { 1 } , y _ { 2 } )$ – the second border of the strip $G$ .   
+Figure 8: The polytopes $P _ { 1 }$ and $P _ { 1 } ^ { \lambda }$ and the interpolator $g$
+
+Now, denote
+
+$$
+W _ { k } ^ { \lambda } = \big \{ w \in W : c _ { k } ( w ) \leq \lambda \big | f ( z _ { k } ) - f ( y _ { 1 } ) \big | \big \} \quad \mathrm { f o r } \ k = 1 , \dots , \ell .
+$$
+
+Each $W _ { k } ^ { \lambda }$ is a half-space in $W$ containing $W _ { k } ^ { - }$ and hence $P _ { 1 }$ . Let us set $\begin{array} { r } { P _ { 1 } ^ { \lambda } = \bigcap _ { k = 1 } ^ { \ell } W _ { k } ^ { \lambda } } \end{array}$ . Clearly, $P _ { 1 } \subseteq P _ { 1 } ^ { \lambda }$ (see Fig. 8). By Observation 5, the distance of the hyperplane $\{ w \in W : c _ { k } ( w ) =$ $\lambda { \big | } f ( z _ { k } ) - f ( y _ { 1 } ) { \big | } \}$ from $P _ { 1 }$ is at most $\lambda K$ , where $K$ is given by (8). Therefore, since all the facets of $P _ { 1 } ^ { \lambda }$ are at most $\lambda K$ far from $P _ { 1 }$ , there is a constant $C$ such that each point of $P _ { 1 } ^ { \lambda }$ is at most $C \lambda$ far from $P _ { 1 }$ .
+
+Finally, choose any $w _ { 1 } \in P _ { 1 } ^ { \lambda } \cap F _ { \lambda } ( y _ { 1 } , y _ { 2 } )$ . By (16), we have $g ( w _ { 1 } ) = f ( y _ { 1 } )$ , and by the definition of $P _ { 1 } ^ { \lambda }$ , $w _ { 1 }$ is no farther than $C \lambda$ away from $P _ { 1 }$ .
+
+Now, let us treat $y _ { 2 }$ and define the set $P _ { 2 } ^ { \lambda }$ analogous to $P _ { 1 } ^ { \lambda }$ , where each occurrence of $y _ { 1 }$ is replaced by $y _ { 2 }$ . Any $w _ { 2 } \in \mathring { P } _ { 2 } ^ { \lambda } \cap F ( y _ { 1 } , y _ { 2 } )$ has desired properties. Indeed, (15) ensures that $g ( w _ { 2 } ) = f ( y _ { 2 } )$ and $w _ { 2 }$ is at most $C \lambda$ far away from $P _ { 2 }$ . □
+
+# A.3 DETAILS OF EXPERIMENTS
+
+# A.3.1 WARCRAFT SHORTEST PATH
+
+The maps for the dataset have been generated with a custom random generation process by using 142 tiles from the Warcraft II tileset (Guyomarch, 2017). The costs for the different terrain types range from 0.8–9.2. Some example maps of size $1 8 \times 1 8$ are presented in Fig. 9a together with a histogram of the shortest path lengths. We used the first five layers of ResNet18 followed by a max-pooling operation to extract the latent costs for the vertices.
+
+Optimization was carried out via Adam optimizer (Kingma & Ba, 2014) with scheduled learning rate drops dividing the learning rate by 10 at epochs 30 and 40. Hyperparameters and model details are listed in Tab. 5
+
+Table 5: Experimental setup for Warcraft Shortest Path.   
+
+<table><tr><td>k</td><td>Optimizer(LR)</td><td>Architecture</td><td>Epochs</td><td>Batch Size</td><td>入</td></tr><tr><td>12,18,24, 30</td><td>Adam(5 × 10-4)</td><td>subset of ResNet18</td><td>50</td><td>70</td><td>20</td></tr></table>
+
+![](images/c4d7d1fad40aeeed7fe8bf5d7996e0f53a046bbf953f327668bd1e20bdbb8a7e.jpg)  
+Figure 9: Warcraft SP(18) dataset.
+
+# A.3.2 MNIST MIN-COST PERFECT MATCHING
+
+The dataset consists of randomly generated grids of MNIST digits that are sampled from a subset of 1000 digits of the full MNIST dataset. We trained a fully convolutional neural network with two convolutional layers followed by a max-pooling operation that outputs a $k \times k$ grid of vertex costs for each example. The vertex costs are transformed into the edge costs via the known cost function and the edge costs are then the inputs to the Blossom $\mathrm { v }$ solver (Edmonds, 1965) as implemented in (Kolmogorov, 2009).
+
+Regarding the optimization procedure, we employed the Adam optimizer along with scheduled learning rate drops dividing the learning rate by 10 at epochs 10 and 20, respectively. Other training details are in Tab. 6. Lower batch sizes were used to reduce GPU memory requirements.
+
+Table 6: Experimental setup for MNIST Min-cost Perfect Matching.   
+
+<table><tr><td>k</td><td>Optimizer(LR)</td><td>Architecture [channels,kernel size, stride]</td><td>Epochs</td><td>Batch Size</td><td>入</td></tr><tr><td>4,8</td><td>Adam(10-3)</td><td>[[20,5,1],[20, 5,1]]</td><td>30</td><td>70</td><td>10</td></tr><tr><td>16</td><td>Adam(10-3)</td><td>[[50, 5,1], [50, 5,1]]</td><td>30</td><td>40</td><td>10</td></tr><tr><td>24</td><td>Adam(10-3)</td><td>[50, 5,1], [50, 5,1]]</td><td>30</td><td>30</td><td>10</td></tr></table>
+
+# A.3.3 GLOBE TRAVELING SALESMAN PROBLEM
+
+For the Globe Traveling Salesman Problem we used a convolutional neural network architecture of three convolutional layers and two fully connected layers. The last layer outputs a vector of dimension $3 k$ containing the $k$ 3-dimensional representations of the respective countries’ capital cities. These representations are projected onto the unit sphere and the matrix of pairwise distances is fed to the TSP solver.
+
+The high combinatorial complexity of TSP has negative effects on the loss landscape and results in many local minima and high sensitivity to random restarts. For reducing sensitivity to restarts, we set Adam parameters to $\beta _ { 1 } = 0 . 5$ (as it is done for example in GAN training (Radford et al., 2015)) and $\epsilon = 1 \dot { 0 } ^ { - 3 }$ .
+
+The local minima correspond to solving planar TSP as opposed to spherical TSP. For example, if all cities are positioned to almost identical locations, the network can still make progress but it will never have the incentive to spread the cities apart in order to reach the global minimum. To mitigate that, we introduce a repellent force between epochs 15 and 30. In particular, we set
+
+$$
+L _ { \mathrm { r e p } } = \underset { i \neq j } { \mathbb { E } } e ^ { - \| x _ { i } - x _ { j } \| }
+$$
+
+where $x _ { i } \in \mathbb { R } ^ { 3 }$ for $i = 1 , \ldots , k$ are the positions of the $k$ cities on the unit sphere. The regularization constants $C _ { k }$ were chosen as 2.0, 3.0, 6.0, and 20.0 for $k \in \{ 5 , 1 0 , 2 0 , 4 0 \}$ .
+
+For fine-tuning we also introduce scheduled learning rate drops where we divide the learning rate by 10 at epochs 80 and 90.
+
+Table 7: Experimental setup for the Globe Traveling Salesman Problem.   
+
+<table><tr><td rowspan="2">k</td><td rowspan="2">Optimizer(LR)</td><td colspan="2">Architecture [channels,kernel size, stride],</td><td rowspan="2">Epochs</td><td rowspan="2">Batch Size</td><td rowspan="2">入</td></tr><tr><td>linear layer size</td><td></td></tr><tr><td>5,10,20</td><td>Adam(10-4)</td><td>[[20, 4,2], [50,4,2], 500]</td><td></td><td>100</td><td>50</td><td>20</td></tr><tr><td>40</td><td>Adam(5 × 10-5)</td><td>[20,4,2],[50,4,2],500]</td><td></td><td>100</td><td>50</td><td>20</td></tr></table>
+
+In Fig. 5b, we compare the true city locations with the ones learned by the hybrid architecture. Due to symmetries of the sphere, the architecture can embed the cities in any rotated or flipped fashion. We resolve this by computing “the most favorable” isometric transformation of the suggested locations. In particular, we solve the orthogonal Procrustes problem (Gower & Dijksterhuis, 2004)
+
+$$
+R ^ { * } = \underset { R : R ^ { T } R = I } { \arg \operatorname* { m i n } } \| R X - Y \| ^ { 2 }
+$$
+
+where $X$ are the suggested locations, $Y$ the true locations, and $R ^ { * }$ the optimal transformation to apply. We report the resulting offsets in kilometers in Tab. 8.
+
+Table 8: Average errors of city placement on the Earth.   
+
+<table><tr><td>k</td><td>5</td><td>10</td><td>20</td><td>40</td></tr><tr><td>Location offset (km)</td><td>69±11</td><td></td><td>19±511±5</td><td>58±7</td></tr></table>
+
+# A.4 TRAVELING SALESMAN WITH AN APPROXIMATE SOLVER
+
+Since approximate solvers often appear in practice where the combinatorial instances are too large to be solved exactly in reasonable time, we test our method also in this setup. In particular, we use the approximate solver (OR-Tools (ort, 2019)) for the Globe TSP. We draw two conclusions from the numbers presented below in Tab. 9.
+
+(i) The choice of the solver matters. Even if OR-Tools is fed with the ground truth representations (i.e. true locations) it does not achieve perfect results on the test set (see the right column). We expect, that also in practical applications, running a suboptimal solver (e.g. a differentiable relaxation) substantially reduces the maximum attainable performance.   
+(ii) The suboptimality of the solver didn’t harm the feature extraction – the point of our method. Indeed, the learned locations yield performance that is close to the upper limit of what the solver allows (compare the middle and the right column).
+
+Table 9: Perfect path accuracy for Globe TSP using the approximate solver OR-Tools (ort, 2019). The maximal achievable performance is in the right column, where the solver uses the ground truth city locations.   
+
+<table><tr><td colspan="3">Embedding OR-tools</td><td>OR-tools on GT locations</td></tr><tr><td>k</td><td>Train %</td><td>Test %</td><td>Test %</td></tr><tr><td>5</td><td>99.8 ±0.0</td><td>99.3 ± 0.1</td><td>100.0</td></tr><tr><td>10</td><td>84.3 ± 0.2</td><td>84.4±0.2</td><td>88.6</td></tr><tr><td>20</td><td>49.2 ±0.2</td><td>48.6± 0.8</td><td>54.4</td></tr><tr><td>40</td><td>14.6 ± 0.1</td><td>15.1 ± 0.3</td><td>15.2</td></tr></table>

parse/train/Esd7tGH3Spl/Esd7tGH3Spl.md

@@ -0,0 +1,244 @@
+# Evaluating Efficient Performance Estimators of Neural Architectures
+
+Xuefei Ning1] Changcheng Tang2
+
+Wenshuo Li1
+
+Zixuan Zhou1
+
+Shuang Liang2
+
+Huazhong Yang1†
+
+Yu Wang1‡
+
+Department of Electronic Engineering, Tsinghua University1 Novauto Technology Co. Ltd.2 ]foxdoraame@gmail.com, †yanghz@tsinghua.edu.cn, ‡yu-wang@tsinghua.edu.cn
+
+# Abstract
+
+Conducting efficient performance estimations of neural architectures is a major challenge in neural architecture search (NAS). To reduce the architecture training costs in NAS, one-shot estimators (OSEs) amortize the architecture training costs by sharing the parameters of one “supernet” between all architectures. Recently, zero-shot estimators (ZSEs) that involve no training are proposed to further reduce the architecture evaluation cost. Despite the high efficiency of these estimators, the quality of such estimations has not been thoroughly studied. In this paper, we conduct an extensive and organized assessment of OSEs and ZSEs on five NAS benchmarks: NAS-Bench-101/201/301, and NDS ResNet/ResNeXt-A. Specifically, we employ a set of NAS-oriented criteria to study the behavior of OSEs and ZSEs, and reveal their biases and variances. After analyzing how and why the OSE estimations are unsatisfying, we explore how to mitigate the correlation gap of OSEs from three perspectives. Through our analysis, we give out suggestions for future application and development of efficient architecture performance estimators. Furthermore, the analysis framework proposed in our work could be utilized in future research to give a more comprehensive understanding of newly designed architecture performance estimators. The code is available at https://github. com/walkerning/aw_nas [24].
+
+# 1 Introduction
+
+Neural architecture search (NAS) can automatically discover architectures that outperform the handcrafted ones for various applications [48, 10, 11]. Early NAS methods [48, 30] suffer from an extremely heavy computational burden, and can take tens of thousands of GPU hours to run. One of the major reasons for the computational challenge of NAS is that evaluating each candidate architecture is slow, which includes a full training and testing process. In the past years, studies [2, 27, 3, 5, 8, 45, 20, 1] have been focusing on developing more efficient performance estimators of neural architectures.
+
+One-shot Estimator (OSE) Traditional NAS methods [48, 30, 2] conduct a costly separate training process to acquire the suitable parameters to evaluate each candidate architecture. To make NAS computationally tractable, ENAS [27] proposes the parameter-sharing technique to accelerate the architecture evaluation. Following this work, the parameter sharing technique is widely used for architecture search in different search spaces [39, 16] or incorporated with different search strategies [19, 16, 23, 40]. We refer to the parameter-sharing estimations as the “one-shot” estimations since it requires the training cost of one supernet.
+
+How well the one-shot estimations are correlated with the standalone architecture performances is essential for the efficacy of NAS methods. Despite the widespread use of OSEs, studies [43] have revealed that the OSE estimations might fail to reflect the true ranking of architectures. However, their experiments are conducted in a toy search space with only 32 architectures. In this work, we conduct a more comprehensive study on OSEs in five search spaces with distinct properties, including three topological search spaces (NAS-Bench-101 [41], NAS-Bench-201 [9], and NAS-Bench-301 [32]), and two non-topological search spaces [29] (NDS ResNet, and NDS ResNeXt-A). We further analyze how and why OSE estimations have bias and variance, and explore how to improve OSEs.
+
+Zero-shot Estimator (ZSE) More recently, in order to further reduce the architecture evaluation cost, several studies [20, 1, 15, 17, 26, 6] introduce “zero-shot” estimators that involve no training. In this work, we study various ZSEs on several benchmarks and reveal their properties and weakness.
+
+Knowledge Our work reveals pieces of knowledge on OSEs and ZSEs. First of all, some behaviors of OSEs and ZSEs vary across search spaces (Appendix A.1.1, Sec. 4.2). Some of the common knowledge for OSEs revealed by our work include 1) OSEs bias towards architectures with lower complexity in the early training phase [18]. And this bias can be alleviated to various extents with sufficient training in different spaces (Sec. 5.1). 2) OSEs have variance and can be mitigated to some extent (Sec. 5.3, Sec. 6.1). 3) Reducing the sharing extent of OSEs can potentially improve their ranking quality [47] (Sec. 6.3).
+
+As for ZSEs, we reveal that 1) Current ZSEs cannot benefit from one-shot training. The ranking qualities of ZSEs utilizing high-order information (i.e., gradients) even degrade a lot after one-shot training (Sec. 4.2). 2) Parameter-level ZSEs adapted from pruning literature are not suitable for ranking architectures, and their ranking qualities cannot surpass those of parameter size (#Param) or #FLOPs (Sec. 4.2). 3) Existing ZSEs have improper biases, some overestimate linear architectures without skip connections, and some overestimate architectures with smaller kernel sizes and receptive fields (Sec. 5.2). 4) The relative effectiveness of ZSEs varies between search spaces, relu_logdet [21] is the best on the three topological search spaces, and synflow [33] is better on the two non-topological search spaces (Sec. 4.2). 5) Most ZSEs are not sensitive to the input data distribution: They get similar architecture rankings when using random noises as the input (Appendix B.1).
+
+Suggestions Based on our experiments and analyses, we give out suggestions for future OSE applications. For example: 1) Longer training makes one-shot estimations better (Sec. 4.1); 2) Using one-shot loss instead of accuracy significantly improves the ranking qualities in the DARTS space [16] (Sec. 4.1); 3) One should use enough validation data for OSEs, instead of merely several batches as in ZSEs (Sec. 4.1); 4) Using temporal ensemble helps reduce the ranking instability, and brings non-negative improvements on the ranking quality in different search spaces (Sec. 6.1); 5) In search space with isomorphic architectures, augmenting the sampling strategy to improve the sampling fairness is essential to avoid overestimating simple architectures (Sec. 6.2); 6) Affine operation should not be used in batch normalization (BN) during supernet training (Sec. 6.3).
+
+As for ZSEs, we point out several open research problems: 1) Is there a general ZSE suitable for different types of search spaces? 2) Do we need to make ZSEs utilize the input data information better, and how can we do that? 3) Can we develop ZSEs that distinguish top architectures better? We also list out some technical suggestions for improving ZSEs: 1) Future ZSEs should conduct architecture-level analysis instead of using parameter-level analysis (Sec. 4.2). 2) According to some prominent bias of existing ZSEs, we can add some structural knowledge into ZSE voting ensembles, e.g., receptive field analysis seems promising for improving jacob_cov or relu_logdet (Sec. 5.2). 3) In future developments of ZSEs, researchers should add two simple comparison baselines, #Params, and #FLOPs, as they are actually very competitive baseline ZSEs (Sec. 4.2).
+
+Our work provides strong baselines and diagnosis tools for future research of architecture performance estimators, and we suggest future research to utilize these baselines and tools for a more comprehensive understanding of newly designed performance estimators.
+
+Analysis Framework Our analysis framework of efficient architecture performance estimators is organized as follows. We first introduce the evaluation criteria for estimator quality in Sec. 3. And Sec. 4 presents the quality evaluation of multiple OSEs and ZSEs. Then, we conduct an organized analysis on how and why the OSE and ZSE estimations have biases and variances in Sec. 5. Specifically, their complexity-level, operation-level, and architecture-level biases are demonstrated and analyzed. And the stability of OSE accuracy and ranking along the training process are analyzed. And in Sec. 6, based on our analysis framework, we present several case studies on improving OSEs from three perspectives: i.e. reducing the variance, bias, and parameter sharing extent.
+
+# 2 Related Work
+
+# 2.1 Efficient Performance Estimators of Neural Architectures
+
+One-shot Estimators The vanilla NAS method [48] trains each architecture for 50 epochs to acquire its suitable parameters, which makes the NAS process prohibitively costly. As a remedy, ENAS [27] proposes to amortize the separate training costs by sharing parameters among architectures. Specifically, ENAS constructs an over-parametrized supernet such that all architectures can be evaluated using its parameter subsets. Throughout the search process, the shared supernet parameters are updated on the training set, and an RNN controller is updated alternatively on the validation set.
+
+There are two types of parameter-sharing methods: 1) One-shot NAS methods [3, 13] that first train a supernet and then conduct architecture search without further supernet tuning. 2) Non-one-shot methods [27, 16, 40] that conduct supernet training and architecture search (i.e. controller update) jointly. And this work focuses on evaluating the estimations of the “one-shot” supernet, since it is the cleaner case without the complexity of varying controller settings and possible controller-supernet co-adaption. In each supernet training step, S architectures are randomly sampled to process a batch of training data. Here S denotes the number of Monte-Carlo architecture samples. Then, the gradients of these architectures are averaged to update the supernet.
+
+Correlation of One-shot Estimators There exist some studies that carry out correlation evaluation for one-shot estimators. Zhang et al. [45] compare the correlation of OSEs and their proposed hyper-network-based estimator. However, their work is not aiming for a large-scale evaluation of OSEs and ZSEs, thus they only evaluate the OSE correlations on one search space, and do not conduct further analysis. Yu et al. [43] conduct parameter sharing NAS in a toy RNN search space with only 32 architectures in total, and discover that the parameter sharing rankings do not correlate with the true rankings of architectures. Zela et al. [44] also report that the correlation of parameter-sharing estimations is not satisfying with a Spearman correlation coefficient between -0.25 and 0.3 on a larger search space with around $1 5 \mathrm { k }$ architectures. Pourchot et al. [28] evaluate the Spearman’s ranking correlation of OSEs on NAS-Bench-101. Yu et al. [42] provide an analysis on how the heuristics and hyperparameters influence the supernet training on three benchmarks (i.e. NAS-Bench-101, NAS-Bench-201, and DARTS-NDS). But they only use the variants of Kendall’s Tau as the evaluation criteria, and do not further explore the biases and failing reasons of OSEs. Zhang et al. [47] point out the instability and poor ranking correlation of OSEs, and claim that the high extent of parameter sharing causes the unsatisfying performance. However, they only conduct experiments on a small search space with about 200 architectures.
+
+In this paper, we conduct a more comprehensive study of OSE behaviors across five search spaces, and further investigate how and why the OSE estimations are not satisfying. We also propose and compare several techniques to mitigate the OSE correlation gap.
+
+Zero-shot Estimators More recently, in order to further reduce the architecture evaluation cost, several researches [20, 1] propose “zero-shot” estimators that conduct no training and use random initialized models to estimate architecture performances. Based on the observation that good architectures have distinct local jacobian on different images, Mellor et al. [20] propose an indicator based on input jacobian correlation. Lopes et al. [17] improve the above indicator by calculating the jacobian correlation with respect to the class. Abdelfattah et al. [1] adapt several ZSEs from the pruning literature, and claim that these adapted ZSEs can perform well on NAS-Bench-201. Lin et al. [15] define the expected Gaussian complexity to measure the network expressivity, and efficiently discover architectures with state-of-the-art accuracy on ImagetNet. With a small training overhead, Ru et al. [31] propose to evaluate an architecture’s performance by its training speed. Concurrent to our work, White et al. [38] also evaluate various performance estimators on multiple benchmarks.
+
+# 2.2 NAS Benchmarks
+
+NAS benchmarks are proposed to enable researchers to verify the effectiveness of NAS methods efficiently. NAS-Bench-101 (NB101) [41] provides the performances of the $4 2 3 \mathrm { k }$ valid architectures in a cell-based search space. OSE cannot be easily applied for the whole NB101 search space due to its specific channel number rule. To reuse NB101 for benchmarking OSE, NAS-Bench-1shot1 (NB1shot) [44] picks out three sub-spaces of NB101, and a supernet can be easily constructed for these sub-spaces. In this work, we use the largest sub-space in NB1shot: NB1shot-3, and use the name “NB101” to refer to it. Another benchmark, NAS-Bench-201 (NB201) [9], provides the performances of all the 15625 architectures in a single-cell search space. Previous tabular benchmarks exhaustively train all architectures in a search space much smaller than commonly-used ones (e.g. DARTS [16] with size over $1 0 ^ { 1 8 }$ ). Recently, NAS-Bench-301 (NB301) [32] is proposed as a benchmark in the DARTS space. It adopts a surrogate-based methodology that predicts architecture performances with the performances of about 60k anchor architectures.
+
+Besides these benchmarks on cell-based topological search spaces, we also experiment with two nontopological benchmarking search spaces [29], NDS ResNet, and NDS ResNeXt-A. The architectural decisions in these search spaces are the non-topological hyper-parameters of pre-defined blocks, including kernel size, width, depth, convolution group number, and so on. The properties of these benchmarking search spaces are summarized in Appendix Tab. A1.
+
+# 3 Evaluation Criteria
+
+This section introduces the major evaluation criteria used in our analysis framework, while the analysis criteria and methods of ranking bias and variance will be introduced in Sec. 5. We denote the total number of architectures as $M$ , the true (ground-truth, GT) performances and approximated estimated scores of architectures $\{ a _ { i } \} _ { i = 1 , \cdots , M }$ as $\{ y _ { i } \} _ { i = 1 , \cdots , M }$ and $\{ s _ { i } \} _ { i = 1 , \cdots , M }$ , respectively, and the ranking of the true and estimated score $y _ { i } , s _ { i }$ as $r _ { i } , n _ { i } \in \{ 1 , \cdots , M \}$ , respectively $( r _ { i } = 1$ indicates that $a _ { i }$ is the best architecture). The correlation criteria used in our framework are
+
+• Pearson coefficient of linear correlation (LC): $\operatorname { c o r r } ( y , s ) / { \sqrt { \operatorname { c o r r } ( y , y ) \operatorname { c o r r } ( s , s ) } } .$ .   
+• Kendall’s Tau ranking correlation $( \mathrm { K D } \tau )$ : The relative difference of concordant pairs and   
+discordant pairs $\begin{array} { r } { \sum _ { i < j } \mathrm { s g n } ( y _ { i } - y _ { j } ) \mathrm { s g n } ( s _ { i } - s _ { j } ) / \binom { M } { 2 } } \end{array}$ .   
+• Spearman’s ranking correlation (SpearmanR): The pearson correlation coefficient between the ranking variables $\operatorname { c o r r } ( r , n ) / { \sqrt { \operatorname { c o r r } ( r , r ) \operatorname { c o r r } ( n , n ) } }$ .
+
+Since the ability of differentiating between good architectures matters more than differentiating between bad ones, criteria that emphasize more on the relative order of architectures with good performances are desired. Denoting $A _ { K } = \{ a _ { i } | n _ { i } < K M \}$ as the set of architectures whose estimated scores $s$ are among the top $K$ portion of the search space, we use two set of criteira [25]:
+
+• Precision $@ \mathrm { K }$ $\begin{array} { r } { ( \mathrm { P } \ @ \mathrm { t o p K } ) \in ( 0 , 1 ] = \frac { \# \{ i | r _ { i } < K M \wedge n _ { i } < K M \} } { K M } ; } \end{array}$ : The proportion of true top-K proportion architectures in the top- ${ \bf \nabla } \cdot { \bf K }$ architectures according to the scores. • BestRanking $@ \mathrm { K }$ $\mathrm { \sf ~ \zeta ( B R @ K ) } \in ( 0 , 1 ] = \mathrm { a r g } \operatorname* { m i n } _ { \alpha _ { i } \in A _ { K } } r _ { i } / M$ : The best normalized ranking among the top K proportion of architectures according to the scores (Lower is better).
+
+Corresponding to P@topK, we also compare P@bottomK = #{i|ri>(1−K)M ∧ ni>(1−K)M} to reveal how the worst architectures are distinguished. And corresponding to $\mathrm { B R @ K }$ , we inspect WorstRanking $@ \mathrm { K }$ $\operatorname { K } \left( \operatorname { W R } \circledast \operatorname { K } \right) = \arg \operatorname* { m a x } _ { \alpha _ { i } \in A _ { K } } { r _ { i } } / M$ to reveal how the supernet is likely to regard a bad architecture to be good (Lower is better). Note that the rankings and architecture numbers are all relative numbers normalized by the total architecture number $M$ .
+
+# 4 Evaluating Efficient Performance Estimators
+
+# 4.1 Evaluation of One-shot Estimators
+
+Trend of Different Criteria We inspect how these proposed criteria evolve during the training process. Unless otherwise noted, MC sample $S { = } 1$ is used in the experiments. And all training and evaluation settings are summarized in Appendix D. Fig. 1 and Appendix Fig. A24 show the criteria trend on topological and non-topological search spaces, respectively. We can see that the convergence speeds of criteria are different, and on all search spaces except NB101, all criteria show a rising trend as the training goes on, indicating that OSE gives better rankings with sufficient training.
+
+Another fact is that on all search spaces except NB101, OSEs are better at distinguishing bad architectures (higher $\mathbf { P } \ @ \mathbf { b o t t o m } 5 \%$ ) than distinguishing good ones (lower $\mathbf { P } @ \mathbf { t o p } 5 \%$ ). This indicates that, although identifying the exactly optimal architecture might be difficult for OSEs, using them to filter bad architectures or warm-up sample-based NAS can be very effective. The results of more criteria are shown in Appendix Fig. A1.
+
+![](images/b8304783e77c6ebf99ae48f039807233487e76c290dc781e59acd148282487ed.jpg)  
+Figure 1: Top /Bottom: Criteria of using OS accuracy / OS loss as the estimations (right Y-axis: OS loss value). “Oneshot average” means the average oneshot score (accuracy or loss).
+
+In the NB301 (DARTS) space, OS loss gives significantly better estimations than OS accuracy. For example, at epoch 1000, the KD $\tau$ of OS acc and loss are 0.381 and 0.512, respectively, while their $\mathrm { P @ t o p 5 \% }$ are $1 3 . 8 \%$ and $3 1 . 0 \%$ . This is because the loss value considers the network’s output distribution rather than a single label prediction, it has a less concentrated distribution and is more informative in ranking architectures. Fig. 2 shows that the OS accuracy distribution is indeed more concentrated than the OS loss on NB301.
+
+![](images/3d35aced6ca20a2e7936259372175c9884ec3242abfba7f15399adfac9a8d8eb.jpg)  
+Figure 2: The distribution of OS accuracy and loss.
+
+Effect of the Validation Data Size We inspect OSEs’ ranking quality when using different numbers of validation data batches to evaluate the OS scores, and find that on both NB201/NB301, using more data improves the estimation quality. Specifically, we compute the average OS accuracies over $_ \mathrm { N }$ validation batches, where each batch contains 128 examples. And the effect of the batch number N on the ranking quality is shown in Fig. 3 and Appendix Fig. A3. Fig. 3 shows that on NB301, criteria get better when the batch number increases from 1 to 10 at epoch 1000. Interestingly, when the training is not sufficient (epoch 200), the criteria decrease with more data batches (especially those of the OS acc). To explain this, Fig. 3(upper right) shows the intra-“level” KD histogram, where architectures with the same OS accuracy using one validation batch are said to be in the same level. We can see that when the supernet is under-trained, it is not good at distinguishing between intra-level architectures (negative intra-level KDs). Therefore, using more validation data might bring negative impacts, while giving tie scores can avoid making wrong comparisons between similar architectures.
+
+# 4.2 Evaluation of Zero-shot Estimators
+
+Our work evaluates six parameter-level ZSEs and two architecture-level ZSEs. The six parameterlevel ZSEs are grad_norm, plain [22], snip [14], grasp [36], fisher [34, 35], and synflow [33]. These ZSEs are named after sensitivity indicators initially designed for fine-grained network pruning that measure the approximate loss change when certain parameters or activations are pruned. A recent work [1] proposes to sum up parameter-wise sensitivities of all parameters to evaluate an architecture. And architecture-level ZSEs measure the architecture’s discriminability by inference differences between different input images: jacob_cov [20] uses the input jacobian correlation, and relu_logdet [21] uses activation differences.
+
+![](images/881521b6730a6bd1f4e7cd29a61ace352aa7330c41d5d6a85f1ae466f167f1d2.jpg)  
+Figure 3: Criteria vary on NB301 as the batch number (X-axis) changes. Right: The histogram of intra-level KDs using 10-batch OS acc, the “levels” are partitioned according to 1-batch OS acc. Since batch_size ${ \mathrel { = } } 1 2 8$ , at most 128 levels can exist. The legend gives out the actual number of levels in 1-batch evaluation with format “#acc levels with #arch>1 / #total”.
+
+The full evaluation results of ZSEs are shown in Appendix B and C, and Fig. 4 shows some of the results on NB201 and NB301. We can see that the ranking correlations of ZSEs except relu_logdet are even worse than the GT-Param correlation. Also, the relative effectiveness of ZSEs varies between search spaces. For example, on NB301, plain performs better than other ZSEs except
+
+![](images/0d8eec200ae47c370661711c4509e608c8fac6a10d52bb363270216a333f9730.jpg)  
+Figure 4: KD between GT, FLOPs/Params, OSEs (1k epoch) and ZSEs. Left: NB201; Right: NB301.
+
+relu_logdet, while on NB201, plain performs worst among all ZSEs. And jacob_cov and synflow give relatively good estimations with KD of $0 . 6 1 \mathrm { ~ / ~ } 0 . 5 7$ , but they do not perform well on NB301 (KDs are $0 . 2 3 / 0 . 2 )$ . Also, as shown in Appendix Tab. A12, the best-performing ZSE on topological search spaces, relu_logdet, does not perform well on non-topological NDS ResNet and ResNeXt-A.
+
+The vote ZSE [1] conducts a majority vote between various metrics to compare each pair of architectures. We choose three best-performing ZSEs as the voting experts, and find that this simple form of voting does not bring improvements over the best constituent ZSE. Better ways of ensembling different ZSEs need to be developed.
+
+It is a natural idea to apply ZSEs on trained networks. Thus we explore whether ZSEs can benefit from one-shot training. According to Appendix Tab. A11, current ZSEs cannot benefit from one-shot training. The ranking qualities of ZSEs except relu_logdet even degrade a lot after one-shot training. A possible explanation is that these ZSEs utilize the gradient information, and the gradient magnitudes in a trained supernet are too small and obscure for architecture ranking.
+
+# 5 How & Why the Estimations Are Not Satisfying
+
+# 5.1 Bias of One-shot Estimators
+
+Complexity-level Bias To identify which architectures are under- or overestimated, we investigate the relationship of the true-estimated Ranking Difference (RD) $r _ { i } - n _ { i } ; i = 1 , \cdots , M$ and the architecture complexity (i.e. Params, FLOPs). RD serves as an indicator of overestimation for arch $i$ : A positive RD indicates that this architecture is overestimated. Otherwise, it is underestimated.
+
+Sub-architectures have different amounts of calculation and might converge with a different speed. Thus, we conduct the complexity-level bias analysis. In Fig. 5, we divide the architectures into five
+
+![](images/be6f1be83d88f80f18f1d90c0e7caf03cf1e6699448d1afcbe9416373bedec49.jpg)  
+Figure 5: Complexity-level bias. Left/right Y-axis: KD $\tau$ / Average RD within the complexity group. X-axis: Complexity groups (the group with the smallest FLOPs is at the leftmost).
+
+complexity groups according to the amount of calculation (FLOPs), and show the KD and average RD in each group. In the early training stages (the 1st row), the average RD shows a decreasing trend, which means that the larger the model, the easier it is to be underestimated. This is because larger models converge at a slower speed. As the training goes on (the 2nd and 3rd rows), the absolute average RD decreases, indicating that the issue of underestimating larger models gets alleviated. And on both spaces, the decreasing intra-group KD $\tau$ indicates that it is harder for OSEs to compare larger models than comparing smaller ones.
+
+Op-level Bias We inspect the changes of GT and OS accuracy when one operation is mutated to another (edit distance $^ { = 1 }$ ). On NB301, we examine 23476 mutation pairs and find that the OSE estimations overes
+
+timate the effects brought by dilation (Dil) convolutions (Convs): All mutation types from other operations to DilConvs witness a higher OS increase ratio than the GT one. And the skip_connect operation is underestimated: All mutation pairs from skip_connect cause the OS increase ratio to be higher than the GT one. For example, when mutating one skip_connect operation to dil_conv_5x5, only $3 9 . 0 \%$ out of 2336 pairs get GT increases, while $9 4 . 9 \%$ get OS increases. This phenomenon is more remarkable when we only consider mutation pairs within the largest complexity group (grouped by Param): Only $1 5 . 3 \%$ of 569 pairs get GT increases, while $9 2 . 3 \%$ get OS increases. On NB201, based on a similar inspection of the mutation pairs, we find that OSE estimations slightly overestimate avgpool3x3 and underestimate conv $3 \mathbf { x } 3$ . Generally speaking, the op-level bias on NB201 is not as large as that on NB301. See Appendix A.2.2 for the figures and more results.
+
+# 5.2 Bias of Zero-shot Estimators
+
+![](images/f1b7fb76b8566135b61ab87269543dad37fe963c3f1b3aea3acd73ad5b307df0.jpg)  
+Figure 6: The best architectures ranked by several ZSEs on NB201 and NB301.
+
+Arch-level Bias By inspecting the best and worst architectures indicated by ZSEs, we find that existing ZSEs have improper biases. Fig. 6 shows that synflow has an excessive preference for large architectures. snip, grad_norm and fisher give similar rankings of architectures (see Fig. 4), and show improper preferences for architectures with gradient explosion: On NB201, they show a clear preference for architectures without skip connections, which are far from optimal. This is because gradient magnitudes in these architectures get exploded, and the absolute parameter-wise sensitivity is high. In a word, the parameter-level ZSEs adapted from the fine-grained pruning literature are not very suitable for ranking architectures, since they are designed to reflect the relative parameter-wise sensitivity. And due to their sensitivity to scales and gradient explosion, a simple form of adding up the parameter-wise sensitivity provides improperly biased estimations for architecture performances.
+
+In contrast, architecture-level ZSEs (jacob_cov, relu_logdet) are more reasonable attempts that measure the architectures’ discriminability by inference differences between input images. Nevertheless, as shown in Fig. 6 and Appendix B.2, these two ZSEs prefer architectures with smaller receptive fields (prefer smaller kernel sizes or shallow architectures). Consequently, although these two ZSEs have relatively good ranking correlations on topological search spaces, they have difficulties in picking out top architectures (Poor $\mathrm { P @ }$ topKs, see Appendix Tab. A9).
+
+# 5.3 Variance of One-shot Estimators
+
+Accuracy Forgetting Due to the parameter sharing and the random sample training scheme, the training of subsequent architectures overwrites the weights of previous ones, thus degrades their OS accuracy. This “multi-model forgetting” phenomenon [4, 46] accounts for the variance of OS accuracies. Appendix Fig. A14 verifies the existence of the forgetting phenomenon. For each architecture in one epoch, we define its forgetting value (FV) as $\ a c c _ { 2 } \ - - \ a c c _ { 1 }$ , where $a c c _ { 1 }$ refers to its valid accuracy right after its training, and $a c c _ { 2 }$ refers to its accuracy after all the architectures in this epoch have been trained. Appendix Fig. A14 shows that the forgetting phenomenon exists in the early training stages, where the FVs are negative. As training progresses, the variance of the FVs decreases, which is natural due to the learning rate decay. Also, the mean FV becomes positive, indicating that training other architectures can have positive transferring effects on previous architectures instead of negative ones (i.e. forgetting). This observation can be explained by the increasing trend of inter-architecture gradient similarity in Appendix Fig. A15.
+
+Ranking Stability We demonstrate the ranking stability in Fig. 7, since it plays an important role that influences the NAS process more directly than the accuracy stability. The criteria in this figure (i.e. relative KD, relative $\mathrm { P @ }$ top/bottomK) are calculated with two sets of adjacent OS estimations, while the estimations of the latter checkpoint are taken as the GT one. We can see that the ranking stability increases with sufficient training and the OS rankings of bad architectures are relatively stable (relP $@$ bottomK). On NB301, even with rather sufficient training
+
+![](images/c937c3d5779f53b4b06c43c35e0b94c97a112f032f9d40ea40218b8f8d11948d.jpg)  
+Figure 7: Ranking stability of OSEs.
+
+(1k epoch) where the mean OS accuracy already saturates (Fig. 1), the ranking stability of top architectures is still not high (relP $@$ top $0 . 5 \% { \sim } 0 . 4 6 )$ . This is reasonable since that the accuracy differences between architectures in the DARTS space are smaller. And as expected, averaging the OS accuracy of multiple supernets stabilizes OSE estimations. Also, the temporal weight ensemble of multiple checkpoints can stabilize the estimations (Sec. 6.1).
+
+# 6 How to Improve One-shot Estimations
+
+Since different architectures require different values for supernet parameters, as the side effect of acceleration, parameter sharing serves as the intrinsic reason for the OSE correlation gap. Appendix Fig. A15 shows the gradient similarity distribution between architecture pairs on NB201. We can see that the inter-architecture gradient similarities vary in a large range, and one common phenomenon on NB201 and NB301 is that the mean similarity between architecture pairs is lower in the middle-stage layers and the architectures’ gradients in the very first and last layers are more similar. Another slightly counterintuitive fact is that the gradient directions become more similar as the training goes on, especially on NB201. This can explain the positive transferring effect in the latter training stages.
+
+Due to parameter sharing, the random sample training scheme of OSE causes estimation variances. On the other hand, improper sampling distribution causes estimation biases. There are two types
+
+of reasons for the bias: 1) Some architectures (e.g. with larger complexity) might need higher sampling probability to match their relative performance in standalone training. 2) Architectures are sampled from an unfair distribution, i.e., some architectures have undesirable higher equivalent probabilities.
+
+Echoing the above analysis, this section conducts case studies to improve the OSE estimations from 3 perspectives, i.e. reducing the variance, bias, and parameter sharing extent. Sec. 6.1 experiments with 2 techniques that can reduce the OS estimation variance.And in Sec. 6.2, we demonstrate that using de-isomorphic sampling in space with isomorphic architectures (NB201) helps improve the sampling fairness, thus reduce the estimation bias.
+
+![](images/0b737e4b83011c839d8e9bae028ee47c8e85f8ba990ebeda34a8dfff42344abb.jpg)  
+Figure 8: Effect of ensemble techniques on OSEs. Top: NB201; Bottom: NB301.
+
+# 6.1 Variance Reduction
+
+Temporal Variance Reduction Sec. 5.3 shows that averaging OS scores of several supernets stabilizes the estimations. However, this technique is not practical due to its linearly enlarged consumption, as training k supernets takes k-times more computation. As a remedy, Guo et al. [12] propose to only train one supernet, and stabilize OS estimations by temporally averaging weights of supernet checkpoints. Besides the variance reduction effect shown in Fig. 7, Fig. 8 shows whether ensembling techniques can bring other ranking quality improvements. We can see that temporally ensembling 3 or 5 checkpoints brings improvements on NB201 but brings no bias improvements on NB301.
+
+Sampling Variance Reduction We compare the results of using different MC sample numbers $S$ in supernet training. We also adapt Fair-NAS [7] sampling strategy to NB201 and NB301. Using multiple MC architecture samples has different influences in different spaces: It is beneficial for the estimation quality on NB301, while the estimation quality on NB201 decreases slightly as the MC sample number increases. See Appendix A.3.2 for more detailed results.
+
+# 6.2 Sampling Fairness Improvement
+
+Besides the complexity-level and op-level biases shown in Sec. 5.1, OSEs also have some evident architecture-level biases. The NB201 search space contains many isomorphic architectures with different representations, and there are 6466 unique structures (out of 15625) after de-isomorphism. We find that even after sufficient training, the supernet still overestimates some simple architectures significantly. Fig. 9(left) shows the top-2 ranked architectures by the average of 3 supernet’s OS scores at epoch 1000. With vanilla sampling (Iso), OS estimations bias towards simple architectures (a single Conv) with many isomorphic counterparts (Iso group size ${ } = 3 1 { }$ ). We find that this is because isomorphic architectures have identical gradients w.r.t. shared parameters, so that the shared parameters tend to be optimized towards the gradient directions of architectures with many isomorphic counterparts.
+
+We compare the results of sampling w. or w.o. isomorphic architectures in Fig. 9(right). We can see that using the de-isomorphism (deiso) sampling strategy helps pick out top architectures and brings significant improvements on B $\mathbf { k } @ \mathbf { 0 . 5 } \%$ and ${ \bf P } @ 5 \%$ ( $1 . 9 \%$ to $0 . 2 3 \%$ , $2 1 . 3 \%$ to $4 6 . 7 \%$ ). We also experiment with a post-de-isomorphism (post-deiso) technique, in which the estimations of architectures in an isomorphic group are averaged during testing, while no changes are made during training. We can see that “post-deiso” brings slight improvements on $\mathrm { B R } @ \mathrm { K s }$ and $\mathrm { P @ }$ topKs compared with “no post-deiso”, which might owe to the decreased estimation variances. Actually, the deiso sampling strategy is to find a de-isomorphic representation space and conduct uniform sampling in it, and our study provides another evidence for the statement made by [37] that representations can be critical for NAS methods. More detailed results and discussions are in Appendix A.3.3.
+
+![](images/1527fc7344adb6fe1fb60cc8f7fc743634113c85af2a3247fb193c6f8836a989.jpg)  
+Figure 9: Comparison of Iso / Deiso sampling strategy. Left: Top-2 ranked architectures when the supernet is trained with Iso / Deiso sampling strategy, the legend’s format is “OS acc $( \% ) / \mathrm { G T }$ acc $( \% )$ , Iso group size”. Right: Criteria comparison along the training process.
+
+# 6.3 Sharing Extent Reduction
+
+Operation Pruning We remove one or two operations in the search space (SS) and conduct supernet training on the resulting sub-SS. After training the supernet, we compare the OS estimations on the sub-SS provided by the supernet trained on full SS and the sub-SS. The detailed results and analyses can be found in Appendix A.3.4. And the conclusion is: Sharing extent reduction by removing operations can bring improvements to the average OS scores of the remaining architectures in the sub-SS, especially in the early training stages. However, whether the improved absolute OS scores can bring ranking quality improvements is questionable, and the results vary across SSes.
+
+One-shot Pruning We conduct SS pruning on NB201 by selecting the top $10 \%$ , $2 5 \%$ , $50 \%$ architectures ranked by the OS scores of supernet (epoch 600), and continue to finetune the supernet to 1000 epoch with these architectures. The good news is that on NB201, OS pruning brings improvements on both the average OS score and ranking quality in the sub-SS: $2 . 2 \% / 1 . 3 \% / 0 . 1 \%$ average OS score increases and 0.189/0.046/0.086 KD increases when the sub-SS contains $1 0 \% / 2 5 \% / 5 0 \%$ architectures, respectively. The results reveal the potential of dynamic SS pruning for improving the OSE quality, especially for good architectures. However, this per-architecture hard pruning scheme is not practical since it needs an exhaustive test of the full search space. To explore practical dynamic SS pruning methods, we conduct a case study on per-architecture soft pruning with a jointly-trained controller, where the controller gives higher sampling probability to the architectures with higher OS scores. The results and analyses are shown in Appendix A.3.4.
+
+Remove the Affine Operation in BN We compare using or not using BN affine operations, and give out the comparison results in Appendix A.3.4. And the suggestion is that one should not use BN affine operations in the search process.
+
+# 7 Conclusion
+
+We present an analysis framework of efficient architecture performance estimators in NAS, containing carefully developed criteria and organized analyses. Within the framework, we conduct an in-depth analysis of OSEs and ZSEs on five benchmarking search spaces with distinct properties. Our work reveals the properties, weaknesses (variance and bias) of current architecture performance estimators. For OSEs, we further conclude three directions for their improvements and experiment with several mitigations accordingly. Our work gives out suggestions for future NAS applications and points out research directions to further improve current OSEs and ZSEs. Besides the take-away knowledge, our work also provides strong baselines for future research of efficient performance estimators, and the analysis framework could be utilized to diagnose new performance estimators.
+
+# Acknowledgements
+
+This work was supported by National Natural Science Foundation of China (No. U19B2019, 61832007), Tsinghua EE Xilinx AI Research Fund, Beijing National Research Center for Information Science and Technology (BNRist), and Beijing Innovation Center for Future Chips. We thank Zinan Lin, Tianchen Zhao, and Hanbo Sun for their valuable discussions. Finally, we thank all anonymous reviewers for their constructive suggestions.
+
+# References
+
+[1] Mohamed S. Abdelfattah, Abhinav Mehrotra, Łukasz Dudziak, and Nicholas D. Lane. ZeroCost Proxies for Lightweight NAS. In International Conference on Learning Representations, 2021.   
+[2] Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. In International Conference on Learning Representations Workshop, 2018.   
+[3] Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pages 550–559, 2018.   
+[4] Yassine Benyahia, Kaicheng Yu, Kamil Bennani Smires, Martin Jaggi, Anthony C Davison, Mathieu Salzmann, and Claudiu Musat. Overcoming multi-model forgetting. In International Conference on Machine Learning, pages 594–603. PMLR, 2019.   
+[5] Andrew Brock, Theodore Lim, James Millar Ritchie, and Nicholas J Weston. Smash: One-shot model architecture search through hypernetworks. In International Conference on Learning Representations, 2018.   
+[6] Wuyang Chen, Xinyu Gong, and Zhangyang Wang. Neural architecture search on imagenet in four gpu hours: A theoretically inspired perspective. In International Conference on Learning Representations, 2021.   
+[7] Xiangxiang Chu, Bo Zhang, Ruijun Xu, and Jixiang Li. Fairnas: Rethinking evaluation fairness of weight sharing neural architecture search. arXiv preprint arXiv:1907.01845, 2019.   
+[8] Xuanyi Dong and Yi Yang. One-shot neural architecture search via self-evaluated template network. In Proceedings of the IEEE International Conference on Computer Vision, pages 3681–3690, 2019.   
+[9] Xuanyi Dong and Yi Yang. Nas-bench-201: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations, 2020.   
+[10] Thomas Elsken, Jan Hendrik Metzen, Frank Hutter, et al. Neural architecture search: A survey. The Journal of Machine Learning Research, 20(55):1–21, 2019.   
+[11] Golnaz Ghiasi, Tsung-Yi Lin, and Quoc V Le. Nas-fpn: Learning scalable feature pyramid architecture for object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7036–7045, 2019.   
+[12] Ronghao Guo, Chen Lin, Chuming Li, Keyu Tian, Ming Sun, Lu Sheng, and Junjie Yan. Powering one-shot topological nas with stabilized share-parameter proxy. In Proceedings of the European Conference on Computer Vision, pages 625–641. Springer, 2020.   
+[13] Zichao Guo, Xiangyu Zhang, Haoyuan Mu, Wen Heng, Zechun Liu, Yichen Wei, and Jian Sun. Single path one-shot neural architecture search with uniform sampling. In Proceedings of the European Conference on Computer Vision, pages 544–560. Springer, 2020.   
+[14] Namhoon Lee, Thalaiyasingam Ajanthan, and Philip HS Torr. Snip: Single-shot network pruning based on connection sensitivity. arXiv preprint arXiv:1810.02340, 2018.   
+[15] Ming Lin, Pichao Wang, Zhenhong Sun, Hesen Chen, Xiuyu Sun, Qi Qian, Hao Li, and Rong Jin. Zen-nas: A zero-shot nas for high-performance deep image recognition. In Proceedings of the IEEE International Conference on Computer Vision, pages 347–356, 2021.   
+[16] Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018.   
+[17] Vasco Lopes, Saeid Alirezazadeh, and Luís A Alexandre. Epe-nas: Efficient performance estimation without training for neural architecture search. arXiv preprint arXiv:2102.08099, 2021.   
+[18] Renqian Luo, Tao Qin, and Enhong Chen. Balanced one-shot neural architecture optimization. arXiv preprint arXiv:1909.10815, 2019.   
+[19] Renqian Luo, Fei Tian, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture optimization. In Advances in Neural Information Processing Systems, pages 7816–7827. 2018.   
+[20] Joseph Mellor, Jack Turner, Amos Storkey, and Elliot J. Crowley. Neural architecture search without training. arXiv preprint arXiv:2006.04647, 2021.   
+[21] Joseph Mellor, Jack Turner, Amos Storkey, and Elliot J. Crowley. Neural architecture search without training. In International Conference on Machine Learning, 2021.   
+[22] Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In Advances in Neural Information Processing Systems, pages 107–115, 1989.   
+[23] Niv Nayman, Asaf Noy, Tal Ridnik, Itamar Friedman, Rong Jin, and Lihi Zelnik. Xnas: Neural architecture search with expert advice. Advances in Neural Information Processing Systems, 32:1977–1987, 2019.   
+[24] Xuefei Ning, Changcheng Tang, Wenshuo Li, Songyi Yang, Tianchen Zhao, Niansong Zhang, Tianyi Lu, Shuang Liang, Huazhong Yang, and Yu Wang. aw_nas: A modularized and extensible nas framework. arXiv preprint arXiv:2012.10388, 2020.   
+[25] Xuefei Ning, Yin Zheng, Tianchen Zhao, Yu Wang, and Huazhong Yang. A generic graph-based neural architecture encoding scheme for predictor-based nas. In Proceedings of the European Conference on Computer Vision, 2020.   
+[26] Daniel S Park, Jaehoon Lee, Daiyi Peng, Yuan Cao, and Jascha Sohl-Dickstein. Towards nngp-guided neural architecture search. arXiv preprint arXiv:2011.06006, 2020.   
+[27] Hieu Pham, Melody Guan, Barret Zoph, Quoc Le, and Jeff Dean. Efficient neural architecture search via parameters sharing. In International Conference on Machine Learning, pages 4095–4104. PMLR, 2018.   
+[28] Aloïs Pourchot, Alexis Ducarouge, and Olivier Sigaud. To share or not to share: A comprehensive appraisal of weight-sharing. arXiv preprint arXiv:2002.04289, 2020.   
+[29] Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollár. On network design spaces for visual recognition. In Proceedings of the IEEE International Conference on Computer Vision, pages 1882–1890, 2019.   
+[30] Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In Proceedings of the aaai conference on artificial intelligence, volume 33, pages 4780–4789, 2019.   
+[31] Binxin Ru, Clare Lyle, Lisa Schut, Miroslav Fil, Mark van der Wilk, and Yarin Gal. Speedy performance estimation for neural architecture search, 2021.   
+[32] Julien Siems, Lucas Zimmer, Arber Zela, Jovita Lukasik, Margret Keuper, and Frank Hutter. Nas-bench-301 and the case for surrogate benchmarks for neural architecture search. arXiv preprint arXiv:2008.09777, 2020.   
+[33] Hidenori Tanaka, Daniel Kunin, Daniel LK Yamins, and Surya Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. arXiv preprint arXiv:2006.05467, 2020.   
+[34] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. arXiv preprint arXiv:1801.05787, 2018.   
+[35] Jack Turner, Elliot J Crowley, Michael O’Boyle, Amos Storkey, and Gavin Gray. Blockswap: Fisher-guided block substitution for network compression on a budget. arXiv preprint arXiv:1906.04113, 2019.   
+[36] Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. arXiv preprint arXiv:2002.07376, 2020.   
+[37] Colin White, Willie Neiswanger, Sam Nolen, and Yash Savani. A study on encodings for neural architecture search. Advances in Neural Information Processing Systems, 2020.   
+[38] Colin White, Arber Zela, Binxin Ru, Yang Liu, and Frank Hutter. How powerful are performance predictors in neural architecture search? arXiv preprint arXiv:2104.01177, 2021.   
+[39] Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 10734–10742, 2019.   
+[40] Zhaohui Yang, Yunhe Wang, Xinghao Chen, Boxin Shi, Chao Xu, Chunjing Xu, Qi Tian, and Chang Xu. Cars: Continuous evolution for efficient neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 1829–1838, 2020.   
+[41] Chris Ying, Aaron Klein, Eric Christiansen, Esteban Real, Kevin Murphy, and Frank Hutter. Nas-bench-101: Towards reproducible neural architecture search. In International Conference on Machine Learning, pages 7105–7114. PMLR, 2019.   
+[42] Kaicheng Yu, René Ranftl, and Mathieu Salzmann. How to train your super-net: An analysis of training heuristics in weight-sharing NAS. abs/2003.04276, 2020.   
+[43] Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In International Conference on Learning Representations, 2020.   
+[44] Arber Zela, Julien Siems, and Frank Hutter. Nas-bench-1shot1: Benchmarking and dissecting one-shot neural architecture search. In International Conference on Learning Representations, 2020.   
+[45] Chris Zhang, Mengye Ren, and Raquel Urtasun. Graph hypernetworks for neural architecture search. In International Conference on Learning Representations, 2019.   
+[46] Miao Zhang, Huiqi Li, Shirui Pan, Xiaojun Chang, and Steven Su. Overcoming multi-model forgetting in one-shot nas with diversity maximization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2020.   
+[47] Yuge Zhang, Zejun Lin, Junyang Jiang, Quanlu Zhang, Yujing Wang, Hui Xue, Chen Zhang, and Yaming Yang. Deeper insights into weight sharing in neural architecture search. arXiv preprint arXiv:2001.01431, 2020.   
+[48] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations, 2017.

parse/train/Esd7tGH3Spl/Esd7tGH3Spl_content_list.json

@@ -0,0 +1,1159 @@
+[
+    {
+        "type": "text",
+        "text": "Evaluating Efficient Performance Estimators of Neural Architectures ",
+        "text_level": 1,
+        "bbox": [
+            214,
+            122,
+            787,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xuefei Ning1] Changcheng Tang2 ",
+        "bbox": [
+            214,
+            220,
+            495,
+            237
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wenshuo Li1 ",
+        "bbox": [
+            540,
+            220,
+            633,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Zixuan Zhou1 ",
+        "bbox": [
+            681,
+            222,
+            781,
+            236
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Shuang Liang2 ",
+        "bbox": [
+            254,
+            257,
+            361,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Huazhong Yang1† ",
+        "bbox": [
+            449,
+            256,
+            573,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yu Wang1‡ ",
+        "bbox": [
+            663,
+            256,
+            741,
+            272
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Department of Electronic Engineering, Tsinghua University1 Novauto Technology Co. Ltd.2 ]foxdoraame@gmail.com, †yanghz@tsinghua.edu.cn, ‡yu-wang@tsinghua.edu.cn ",
+        "bbox": [
+            254,
+            286,
+            740,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            337,
+            535,
+            353
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Conducting efficient performance estimations of neural architectures is a major challenge in neural architecture search (NAS). To reduce the architecture training costs in NAS, one-shot estimators (OSEs) amortize the architecture training costs by sharing the parameters of one “supernet” between all architectures. Recently, zero-shot estimators (ZSEs) that involve no training are proposed to further reduce the architecture evaluation cost. Despite the high efficiency of these estimators, the quality of such estimations has not been thoroughly studied. In this paper, we conduct an extensive and organized assessment of OSEs and ZSEs on five NAS benchmarks: NAS-Bench-101/201/301, and NDS ResNet/ResNeXt-A. Specifically, we employ a set of NAS-oriented criteria to study the behavior of OSEs and ZSEs, and reveal their biases and variances. After analyzing how and why the OSE estimations are unsatisfying, we explore how to mitigate the correlation gap of OSEs from three perspectives. Through our analysis, we give out suggestions for future application and development of efficient architecture performance estimators. Furthermore, the analysis framework proposed in our work could be utilized in future research to give a more comprehensive understanding of newly designed architecture performance estimators. The code is available at https://github. com/walkerning/aw_nas [24]. ",
+        "bbox": [
+            232,
+            366,
+            766,
+            616
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            637,
+            310,
+            655
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Neural architecture search (NAS) can automatically discover architectures that outperform the handcrafted ones for various applications [48, 10, 11]. Early NAS methods [48, 30] suffer from an extremely heavy computational burden, and can take tens of thousands of GPU hours to run. One of the major reasons for the computational challenge of NAS is that evaluating each candidate architecture is slow, which includes a full training and testing process. In the past years, studies [2, 27, 3, 5, 8, 45, 20, 1] have been focusing on developing more efficient performance estimators of neural architectures. ",
+        "bbox": [
+            174,
+            669,
+            825,
+            765
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One-shot Estimator (OSE) Traditional NAS methods [48, 30, 2] conduct a costly separate training process to acquire the suitable parameters to evaluate each candidate architecture. To make NAS computationally tractable, ENAS [27] proposes the parameter-sharing technique to accelerate the architecture evaluation. Following this work, the parameter sharing technique is widely used for architecture search in different search spaces [39, 16] or incorporated with different search strategies [19, 16, 23, 40]. We refer to the parameter-sharing estimations as the “one-shot” estimations since it requires the training cost of one supernet. ",
+        "bbox": [
+            174,
+            772,
+            825,
+            869
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "How well the one-shot estimations are correlated with the standalone architecture performances is essential for the efficacy of NAS methods. Despite the widespread use of OSEs, studies [43] have revealed that the OSE estimations might fail to reflect the true ranking of architectures. However, their experiments are conducted in a toy search space with only 32 architectures. In this work, we conduct a more comprehensive study on OSEs in five search spaces with distinct properties, including three topological search spaces (NAS-Bench-101 [41], NAS-Bench-201 [9], and NAS-Bench-301 [32]), and two non-topological search spaces [29] (NDS ResNet, and NDS ResNeXt-A). We further analyze how and why OSE estimations have bias and variance, and explore how to improve OSEs. ",
+        "bbox": [
+            173,
+            876,
+            823,
+            904
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot Estimator (ZSE) More recently, in order to further reduce the architecture evaluation cost, several studies [20, 1, 15, 17, 26, 6] introduce “zero-shot” estimators that involve no training. In this work, we study various ZSEs on several benchmarks and reveal their properties and weakness. ",
+        "bbox": [
+            176,
+            181,
+            821,
+            222
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Knowledge Our work reveals pieces of knowledge on OSEs and ZSEs. First of all, some behaviors of OSEs and ZSEs vary across search spaces (Appendix A.1.1, Sec. 4.2). Some of the common knowledge for OSEs revealed by our work include 1) OSEs bias towards architectures with lower complexity in the early training phase [18]. And this bias can be alleviated to various extents with sufficient training in different spaces (Sec. 5.1). 2) OSEs have variance and can be mitigated to some extent (Sec. 5.3, Sec. 6.1). 3) Reducing the sharing extent of OSEs can potentially improve their ranking quality [47] (Sec. 6.3). ",
+        "bbox": [
+            173,
+            228,
+            825,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As for ZSEs, we reveal that 1) Current ZSEs cannot benefit from one-shot training. The ranking qualities of ZSEs utilizing high-order information (i.e., gradients) even degrade a lot after one-shot training (Sec. 4.2). 2) Parameter-level ZSEs adapted from pruning literature are not suitable for ranking architectures, and their ranking qualities cannot surpass those of parameter size (#Param) or #FLOPs (Sec. 4.2). 3) Existing ZSEs have improper biases, some overestimate linear architectures without skip connections, and some overestimate architectures with smaller kernel sizes and receptive fields (Sec. 5.2). 4) The relative effectiveness of ZSEs varies between search spaces, relu_logdet [21] is the best on the three topological search spaces, and synflow [33] is better on the two non-topological search spaces (Sec. 4.2). 5) Most ZSEs are not sensitive to the input data distribution: They get similar architecture rankings when using random noises as the input (Appendix B.1). ",
+        "bbox": [
+            174,
+            332,
+            825,
+            470
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Suggestions Based on our experiments and analyses, we give out suggestions for future OSE applications. For example: 1) Longer training makes one-shot estimations better (Sec. 4.1); 2) Using one-shot loss instead of accuracy significantly improves the ranking qualities in the DARTS space [16] (Sec. 4.1); 3) One should use enough validation data for OSEs, instead of merely several batches as in ZSEs (Sec. 4.1); 4) Using temporal ensemble helps reduce the ranking instability, and brings non-negative improvements on the ranking quality in different search spaces (Sec. 6.1); 5) In search space with isomorphic architectures, augmenting the sampling strategy to improve the sampling fairness is essential to avoid overestimating simple architectures (Sec. 6.2); 6) Affine operation should not be used in batch normalization (BN) during supernet training (Sec. 6.3). ",
+        "bbox": [
+            174,
+            477,
+            825,
+            602
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As for ZSEs, we point out several open research problems: 1) Is there a general ZSE suitable for different types of search spaces? 2) Do we need to make ZSEs utilize the input data information better, and how can we do that? 3) Can we develop ZSEs that distinguish top architectures better? We also list out some technical suggestions for improving ZSEs: 1) Future ZSEs should conduct architecture-level analysis instead of using parameter-level analysis (Sec. 4.2). 2) According to some prominent bias of existing ZSEs, we can add some structural knowledge into ZSE voting ensembles, e.g., receptive field analysis seems promising for improving jacob_cov or relu_logdet (Sec. 5.2). 3) In future developments of ZSEs, researchers should add two simple comparison baselines, #Params, and #FLOPs, as they are actually very competitive baseline ZSEs (Sec. 4.2). ",
+        "bbox": [
+            174,
+            607,
+            825,
+            733
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our work provides strong baselines and diagnosis tools for future research of architecture performance estimators, and we suggest future research to utilize these baselines and tools for a more comprehensive understanding of newly designed performance estimators. ",
+        "bbox": [
+            176,
+            738,
+            823,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Analysis Framework Our analysis framework of efficient architecture performance estimators is organized as follows. We first introduce the evaluation criteria for estimator quality in Sec. 3. And Sec. 4 presents the quality evaluation of multiple OSEs and ZSEs. Then, we conduct an organized analysis on how and why the OSE and ZSE estimations have biases and variances in Sec. 5. Specifically, their complexity-level, operation-level, and architecture-level biases are demonstrated and analyzed. And the stability of OSE accuracy and ranking along the training process are analyzed. And in Sec. 6, based on our analysis framework, we present several case studies on improving OSEs from three perspectives: i.e. reducing the variance, bias, and parameter sharing extent. ",
+        "bbox": [
+            174,
+            786,
+            825,
+            898
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related Work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            321,
+            106
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 Efficient Performance Estimators of Neural Architectures ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            121,
+            612,
+            136
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One-shot Estimators The vanilla NAS method [48] trains each architecture for 50 epochs to acquire its suitable parameters, which makes the NAS process prohibitively costly. As a remedy, ENAS [27] proposes to amortize the separate training costs by sharing parameters among architectures. Specifically, ENAS constructs an over-parametrized supernet such that all architectures can be evaluated using its parameter subsets. Throughout the search process, the shared supernet parameters are updated on the training set, and an RNN controller is updated alternatively on the validation set. ",
+        "bbox": [
+            174,
+            147,
+            825,
+            232
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "There are two types of parameter-sharing methods: 1) One-shot NAS methods [3, 13] that first train a supernet and then conduct architecture search without further supernet tuning. 2) Non-one-shot methods [27, 16, 40] that conduct supernet training and architecture search (i.e. controller update) jointly. And this work focuses on evaluating the estimations of the “one-shot” supernet, since it is the cleaner case without the complexity of varying controller settings and possible controller-supernet co-adaption. In each supernet training step, S architectures are randomly sampled to process a batch of training data. Here S denotes the number of Monte-Carlo architecture samples. Then, the gradients of these architectures are averaged to update the supernet. ",
+        "bbox": [
+            174,
+            237,
+            825,
+            348
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Correlation of One-shot Estimators There exist some studies that carry out correlation evaluation for one-shot estimators. Zhang et al. [45] compare the correlation of OSEs and their proposed hyper-network-based estimator. However, their work is not aiming for a large-scale evaluation of OSEs and ZSEs, thus they only evaluate the OSE correlations on one search space, and do not conduct further analysis. Yu et al. [43] conduct parameter sharing NAS in a toy RNN search space with only 32 architectures in total, and discover that the parameter sharing rankings do not correlate with the true rankings of architectures. Zela et al. [44] also report that the correlation of parameter-sharing estimations is not satisfying with a Spearman correlation coefficient between -0.25 and 0.3 on a larger search space with around $1 5 \\mathrm { k }$ architectures. Pourchot et al. [28] evaluate the Spearman’s ranking correlation of OSEs on NAS-Bench-101. Yu et al. [42] provide an analysis on how the heuristics and hyperparameters influence the supernet training on three benchmarks (i.e. NAS-Bench-101, NAS-Bench-201, and DARTS-NDS). But they only use the variants of Kendall’s Tau as the evaluation criteria, and do not further explore the biases and failing reasons of OSEs. Zhang et al. [47] point out the instability and poor ranking correlation of OSEs, and claim that the high extent of parameter sharing causes the unsatisfying performance. However, they only conduct experiments on a small search space with about 200 architectures. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            575
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we conduct a more comprehensive study of OSE behaviors across five search spaces, and further investigate how and why the OSE estimations are not satisfying. We also propose and compare several techniques to mitigate the OSE correlation gap. ",
+        "bbox": [
+            176,
+            582,
+            825,
+            625
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Zero-shot Estimators More recently, in order to further reduce the architecture evaluation cost, several researches [20, 1] propose “zero-shot” estimators that conduct no training and use random initialized models to estimate architecture performances. Based on the observation that good architectures have distinct local jacobian on different images, Mellor et al. [20] propose an indicator based on input jacobian correlation. Lopes et al. [17] improve the above indicator by calculating the jacobian correlation with respect to the class. Abdelfattah et al. [1] adapt several ZSEs from the pruning literature, and claim that these adapted ZSEs can perform well on NAS-Bench-201. Lin et al. [15] define the expected Gaussian complexity to measure the network expressivity, and efficiently discover architectures with state-of-the-art accuracy on ImagetNet. With a small training overhead, Ru et al. [31] propose to evaluate an architecture’s performance by its training speed. Concurrent to our work, White et al. [38] also evaluate various performance estimators on multiple benchmarks. ",
+        "bbox": [
+            174,
+            631,
+            825,
+            782
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 NAS Benchmarks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            338,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "NAS benchmarks are proposed to enable researchers to verify the effectiveness of NAS methods efficiently. NAS-Bench-101 (NB101) [41] provides the performances of the $4 2 3 \\mathrm { k }$ valid architectures in a cell-based search space. OSE cannot be easily applied for the whole NB101 search space due to its specific channel number rule. To reuse NB101 for benchmarking OSE, NAS-Bench-1shot1 (NB1shot) [44] picks out three sub-spaces of NB101, and a supernet can be easily constructed for these sub-spaces. In this work, we use the largest sub-space in NB1shot: NB1shot-3, and use the name “NB101” to refer to it. Another benchmark, NAS-Bench-201 (NB201) [9], provides the performances of all the 15625 architectures in a single-cell search space. Previous tabular benchmarks exhaustively train all architectures in a search space much smaller than commonly-used ones (e.g. DARTS [16] with size over $1 0 ^ { 1 8 }$ ). Recently, NAS-Bench-301 (NB301) [32] is proposed as a benchmark in the DARTS space. It adopts a surrogate-based methodology that predicts architecture performances with the performances of about 60k anchor architectures. ",
+        "bbox": [
+            174,
+            828,
+            823,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Besides these benchmarks on cell-based topological search spaces, we also experiment with two nontopological benchmarking search spaces [29], NDS ResNet, and NDS ResNeXt-A. The architectural decisions in these search spaces are the non-topological hyper-parameters of pre-defined blocks, including kernel size, width, depth, convolution group number, and so on. The properties of these benchmarking search spaces are summarized in Appendix Tab. A1. ",
+        "bbox": [
+            174,
+            181,
+            825,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 Evaluation Criteria ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            268,
+            369,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "This section introduces the major evaluation criteria used in our analysis framework, while the analysis criteria and methods of ranking bias and variance will be introduced in Sec. 5. We denote the total number of architectures as $M$ , the true (ground-truth, GT) performances and approximated estimated scores of architectures $\\{ a _ { i } \\} _ { i = 1 , \\cdots , M }$ as $\\{ y _ { i } \\} _ { i = 1 , \\cdots , M }$ and $\\{ s _ { i } \\} _ { i = 1 , \\cdots , M }$ , respectively, and the ranking of the true and estimated score $y _ { i } , s _ { i }$ as $r _ { i } , n _ { i } \\in \\{ 1 , \\cdots , M \\}$ , respectively $( r _ { i } = 1$ indicates that $a _ { i }$ is the best architecture). The correlation criteria used in our framework are ",
+        "bbox": [
+            174,
+            300,
+            825,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Pearson coefficient of linear correlation (LC): $\\operatorname { c o r r } ( y , s ) / { \\sqrt { \\operatorname { c o r r } ( y , y ) \\operatorname { c o r r } ( s , s ) } } .$ .   \n• Kendall’s Tau ranking correlation $( \\mathrm { K D } \\tau )$ : The relative difference of concordant pairs and   \ndiscordant pairs $\\begin{array} { r } { \\sum _ { i < j } \\mathrm { s g n } ( y _ { i } - y _ { j } ) \\mathrm { s g n } ( s _ { i } - s _ { j } ) / \\binom { M } { 2 } } \\end{array}$ .   \n• Spearman’s ranking correlation (SpearmanR): The pearson correlation coefficient between the ranking variables $\\operatorname { c o r r } ( r , n ) / { \\sqrt { \\operatorname { c o r r } ( r , r ) \\operatorname { c o r r } ( n , n ) } }$ . ",
+        "bbox": [
+            217,
+            395,
+            825,
+            482
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the ability of differentiating between good architectures matters more than differentiating between bad ones, criteria that emphasize more on the relative order of architectures with good performances are desired. Denoting $A _ { K } = \\{ a _ { i } | n _ { i } < K M \\}$ as the set of architectures whose estimated scores $s$ are among the top $K$ portion of the search space, we use two set of criteira [25]: ",
+        "bbox": [
+            176,
+            491,
+            825,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Precision $@ \\mathrm { K }$ $\\begin{array} { r } { ( \\mathrm { P } \\ @ \\mathrm { t o p K } ) \\in ( 0 , 1 ] = \\frac { \\# \\{ i | r _ { i } < K M \\wedge n _ { i } < K M \\} } { K M } ; } \\end{array}$ : The proportion of true top-K proportion architectures in the top- ${ \\bf \\nabla } \\cdot { \\bf K }$ architectures according to the scores. • BestRanking $@ \\mathrm { K }$ $\\mathrm { \\sf ~ \\zeta ( B R @ K ) } \\in ( 0 , 1 ] = \\mathrm { a r g } \\operatorname* { m i n } _ { \\alpha _ { i } \\in A _ { K } } r _ { i } / M$ : The best normalized ranking among the top K proportion of architectures according to the scores (Lower is better). ",
+        "bbox": [
+            217,
+            556,
+            825,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Corresponding to P@topK, we also compare P@bottomK = #{i|ri>(1−K)M ∧ ni>(1−K)M} to reveal how the worst architectures are distinguished. And corresponding to $\\mathrm { B R @ K }$ , we inspect WorstRanking $@ \\mathrm { K }$ $\\operatorname { K } \\left( \\operatorname { W R } \\circledast \\operatorname { K } \\right) = \\arg \\operatorname* { m a x } _ { \\alpha _ { i } \\in A _ { K } } { r _ { i } } / M$ to reveal how the supernet is likely to regard a bad architecture to be good (Lower is better). Note that the rankings and architecture numbers are all relative numbers normalized by the total architecture number $M$ . ",
+        "bbox": [
+            174,
+            632,
+            825,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 Evaluating Efficient Performance Estimators ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            723,
+            581,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 Evaluation of One-shot Estimators ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            753,
+            454,
+            768
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Trend of Different Criteria We inspect how these proposed criteria evolve during the training process. Unless otherwise noted, MC sample $S { = } 1$ is used in the experiments. And all training and evaluation settings are summarized in Appendix D. Fig. 1 and Appendix Fig. A24 show the criteria trend on topological and non-topological search spaces, respectively. We can see that the convergence speeds of criteria are different, and on all search spaces except NB101, all criteria show a rising trend as the training goes on, indicating that OSE gives better rankings with sufficient training. ",
+        "bbox": [
+            174,
+            779,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Another fact is that on all search spaces except NB101, OSEs are better at distinguishing bad architectures (higher $\\mathbf { P } \\ @ \\mathbf { b o t t o m } 5 \\%$ ) than distinguishing good ones (lower $\\mathbf { P } @ \\mathbf { t o p } 5 \\%$ ). This indicates that, although identifying the exactly optimal architecture might be difficult for OSEs, using them to filter bad architectures or warm-up sample-based NAS can be very effective. The results of more criteria are shown in Appendix Fig. A1. ",
+        "bbox": [
+            174,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b8304783e77c6ebf99ae48f039807233487e76c290dc781e59acd148282487ed.jpg",
+        "image_caption": [
+            "Figure 1: Top /Bottom: Criteria of using OS accuracy / OS loss as the estimations (right Y-axis: OS loss value). “Oneshot average” means the average oneshot score (accuracy or loss). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            87,
+            823,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the NB301 (DARTS) space, OS loss gives significantly better estimations than OS accuracy. For example, at epoch 1000, the KD $\\tau$ of OS acc and loss are 0.381 and 0.512, respectively, while their $\\mathrm { P @ t o p 5 \\% }$ are $1 3 . 8 \\%$ and $3 1 . 0 \\%$ . This is because the loss value considers the network’s output distribution rather than a single label prediction, it has a less concentrated distribution and is more informative in ranking architectures. Fig. 2 shows that the OS accuracy distribution is indeed more concentrated than the OS loss on NB301. ",
+        "bbox": [
+            174,
+            334,
+            825,
+            416
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/3d35aced6ca20a2e7936259372175c9884ec3242abfba7f15399adfac9a8d8eb.jpg",
+        "image_caption": [
+            "Figure 2: The distribution of OS accuracy and loss. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            431,
+            722,
+            544
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Effect of the Validation Data Size We inspect OSEs’ ranking quality when using different numbers of validation data batches to evaluate the OS scores, and find that on both NB201/NB301, using more data improves the estimation quality. Specifically, we compute the average OS accuracies over $_ \\mathrm { N }$ validation batches, where each batch contains 128 examples. And the effect of the batch number N on the ranking quality is shown in Fig. 3 and Appendix Fig. A3. Fig. 3 shows that on NB301, criteria get better when the batch number increases from 1 to 10 at epoch 1000. Interestingly, when the training is not sufficient (epoch 200), the criteria decrease with more data batches (especially those of the OS acc). To explain this, Fig. 3(upper right) shows the intra-“level” KD histogram, where architectures with the same OS accuracy using one validation batch are said to be in the same level. We can see that when the supernet is under-trained, it is not good at distinguishing between intra-level architectures (negative intra-level KDs). Therefore, using more validation data might bring negative impacts, while giving tie scores can avoid making wrong comparisons between similar architectures. ",
+        "bbox": [
+            173,
+            584,
+            825,
+            751
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 Evaluation of Zero-shot Estimators ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            770,
+            459,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our work evaluates six parameter-level ZSEs and two architecture-level ZSEs. The six parameterlevel ZSEs are grad_norm, plain [22], snip [14], grasp [36], fisher [34, 35], and synflow [33]. These ZSEs are named after sensitivity indicators initially designed for fine-grained network pruning that measure the approximate loss change when certain parameters or activations are pruned. A recent work [1] proposes to sum up parameter-wise sensitivities of all parameters to evaluate an architecture. And architecture-level ZSEs measure the architecture’s discriminability by inference differences between different input images: jacob_cov [20] uses the input jacobian correlation, and relu_logdet [21] uses activation differences. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            909
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/881521b6730a6bd1f4e7cd29a61ace352aa7330c41d5d6a85f1ae466f167f1d2.jpg",
+        "image_caption": [
+            "Figure 3: Criteria vary on NB301 as the batch number (X-axis) changes. Right: The histogram of intra-level KDs using 10-batch OS acc, the “levels” are partitioned according to 1-batch OS acc. Since batch_size ${ \\mathrel { = } } 1 2 8$ , at most 128 levels can exist. The legend gives out the actual number of levels in 1-batch evaluation with format “#acc levels with #arch>1 / #total”. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            90,
+            826,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The full evaluation results of ZSEs are shown in Appendix B and C, and Fig. 4 shows some of the results on NB201 and NB301. We can see that the ranking correlations of ZSEs except relu_logdet are even worse than the GT-Param correlation. Also, the relative effectiveness of ZSEs varies between search spaces. For example, on NB301, plain performs better than other ZSEs except ",
+        "bbox": [
+            173,
+            366,
+            356,
+            587
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d8eec200ae47c370661711c4509e608c8fac6a10d52bb363270216a333f9730.jpg",
+        "image_caption": [
+            "Figure 4: KD between GT, FLOPs/Params, OSEs (1k epoch) and ZSEs. Left: NB201; Right: NB301. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            369,
+            367,
+            825,
+            531
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "relu_logdet, while on NB201, plain performs worst among all ZSEs. And jacob_cov and synflow give relatively good estimations with KD of $0 . 6 1 \\mathrm { ~ / ~ } 0 . 5 7$ , but they do not perform well on NB301 (KDs are $0 . 2 3 / 0 . 2 )$ . Also, as shown in Appendix Tab. A12, the best-performing ZSE on topological search spaces, relu_logdet, does not perform well on non-topological NDS ResNet and ResNeXt-A. ",
+        "bbox": [
+            174,
+            588,
+            825,
+            642
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The vote ZSE [1] conducts a majority vote between various metrics to compare each pair of architectures. We choose three best-performing ZSEs as the voting experts, and find that this simple form of voting does not bring improvements over the best constituent ZSE. Better ways of ensembling different ZSEs need to be developed. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            704
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It is a natural idea to apply ZSEs on trained networks. Thus we explore whether ZSEs can benefit from one-shot training. According to Appendix Tab. A11, current ZSEs cannot benefit from one-shot training. The ranking qualities of ZSEs except relu_logdet even degrade a lot after one-shot training. A possible explanation is that these ZSEs utilize the gradient information, and the gradient magnitudes in a trained supernet are too small and obscure for architecture ranking. ",
+        "bbox": [
+            174,
+            710,
+            825,
+            780
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 How & Why the Estimations Are Not Satisfying ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            799,
+            604,
+            816
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 Bias of One-shot Estimators ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            830,
+            408,
+            844
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Complexity-level Bias To identify which architectures are under- or overestimated, we investigate the relationship of the true-estimated Ranking Difference (RD) $r _ { i } - n _ { i } ; i = 1 , \\cdots , M$ and the architecture complexity (i.e. Params, FLOPs). RD serves as an indicator of overestimation for arch $i$ : A positive RD indicates that this architecture is overestimated. Otherwise, it is underestimated. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sub-architectures have different amounts of calculation and might converge with a different speed. Thus, we conduct the complexity-level bias analysis. In Fig. 5, we divide the architectures into five ",
+        "bbox": [
+            173,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/be6f1be83d88f80f18f1d90c0e7caf03cf1e6699448d1afcbe9416373bedec49.jpg",
+        "image_caption": [
+            "Figure 5: Complexity-level bias. Left/right Y-axis: KD $\\tau$ / Average RD within the complexity group. X-axis: Complexity groups (the group with the smallest FLOPs is at the leftmost). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            133,
+            531,
+            310
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "complexity groups according to the amount of calculation (FLOPs), and show the KD and average RD in each group. In the early training stages (the 1st row), the average RD shows a decreasing trend, which means that the larger the model, the easier it is to be underestimated. This is because larger models converge at a slower speed. As the training goes on (the 2nd and 3rd rows), the absolute average RD decreases, indicating that the issue of underestimating larger models gets alleviated. And on both spaces, the decreasing intra-group KD $\\tau$ indicates that it is harder for OSEs to compare larger models than comparing smaller ones. ",
+        "bbox": [
+            547,
+            119,
+            825,
+            325
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Op-level Bias We inspect the changes of GT and OS accuracy when one operation is mutated to another (edit distance $^ { = 1 }$ ). On NB301, we examine 23476 mutation pairs and find that the OSE estimations overes",
+        "bbox": [
+            545,
+            333,
+            823,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "timate the effects brought by dilation (Dil) convolutions (Convs): All mutation types from other operations to DilConvs witness a higher OS increase ratio than the GT one. And the skip_connect operation is underestimated: All mutation pairs from skip_connect cause the OS increase ratio to be higher than the GT one. For example, when mutating one skip_connect operation to dil_conv_5x5, only $3 9 . 0 \\%$ out of 2336 pairs get GT increases, while $9 4 . 9 \\%$ get OS increases. This phenomenon is more remarkable when we only consider mutation pairs within the largest complexity group (grouped by Param): Only $1 5 . 3 \\%$ of 569 pairs get GT increases, while $9 2 . 3 \\%$ get OS increases. On NB201, based on a similar inspection of the mutation pairs, we find that OSE estimations slightly overestimate avgpool3x3 and underestimate conv $3 \\mathbf { x } 3$ . Generally speaking, the op-level bias on NB201 is not as large as that on NB301. See Appendix A.2.2 for the figures and more results. ",
+        "bbox": [
+            173,
+            401,
+            826,
+            540
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 Bias of Zero-shot Estimators ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            411,
+            575
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f1b7fb76b8566135b61ab87269543dad37fe963c3f1b3aea3acd73ad5b307df0.jpg",
+        "image_caption": [
+            "Figure 6: The best architectures ranked by several ZSEs on NB201 and NB301. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            597,
+            825,
+            724
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Arch-level Bias By inspecting the best and worst architectures indicated by ZSEs, we find that existing ZSEs have improper biases. Fig. 6 shows that synflow has an excessive preference for large architectures. snip, grad_norm and fisher give similar rankings of architectures (see Fig. 4), and show improper preferences for architectures with gradient explosion: On NB201, they show a clear preference for architectures without skip connections, which are far from optimal. This is because gradient magnitudes in these architectures get exploded, and the absolute parameter-wise sensitivity is high. In a word, the parameter-level ZSEs adapted from the fine-grained pruning literature are not very suitable for ranking architectures, since they are designed to reflect the relative parameter-wise sensitivity. And due to their sensitivity to scales and gradient explosion, a simple form of adding up the parameter-wise sensitivity provides improperly biased estimations for architecture performances. ",
+        "bbox": [
+            173,
+            772,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In contrast, architecture-level ZSEs (jacob_cov, relu_logdet) are more reasonable attempts that measure the architectures’ discriminability by inference differences between input images. Nevertheless, as shown in Fig. 6 and Appendix B.2, these two ZSEs prefer architectures with smaller receptive fields (prefer smaller kernel sizes or shallow architectures). Consequently, although these two ZSEs have relatively good ranking correlations on topological search spaces, they have difficulties in picking out top architectures (Poor $\\mathrm { P @ }$ topKs, see Appendix Tab. A9). ",
+        "bbox": [
+            174,
+            92,
+            826,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 Variance of One-shot Estimators ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            191,
+            441,
+            205
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Accuracy Forgetting Due to the parameter sharing and the random sample training scheme, the training of subsequent architectures overwrites the weights of previous ones, thus degrades their OS accuracy. This “multi-model forgetting” phenomenon [4, 46] accounts for the variance of OS accuracies. Appendix Fig. A14 verifies the existence of the forgetting phenomenon. For each architecture in one epoch, we define its forgetting value (FV) as $\\ a c c _ { 2 } \\ - - \\ a c c _ { 1 }$ , where $a c c _ { 1 }$ refers to its valid accuracy right after its training, and $a c c _ { 2 }$ refers to its accuracy after all the architectures in this epoch have been trained. Appendix Fig. A14 shows that the forgetting phenomenon exists in the early training stages, where the FVs are negative. As training progresses, the variance of the FVs decreases, which is natural due to the learning rate decay. Also, the mean FV becomes positive, indicating that training other architectures can have positive transferring effects on previous architectures instead of negative ones (i.e. forgetting). This observation can be explained by the increasing trend of inter-architecture gradient similarity in Appendix Fig. A15. ",
+        "bbox": [
+            173,
+            217,
+            825,
+            383
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Ranking Stability We demonstrate the ranking stability in Fig. 7, since it plays an important role that influences the NAS process more directly than the accuracy stability. The criteria in this figure (i.e. relative KD, relative $\\mathrm { P @ }$ top/bottomK) are calculated with two sets of adjacent OS estimations, while the estimations of the latter checkpoint are taken as the GT one. We can see that the ranking stability increases with sufficient training and the OS rankings of bad architectures are relatively stable (relP $@$ bottomK). On NB301, even with rather sufficient training ",
+        "bbox": [
+            174,
+            390,
+            354,
+            707
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/c937c3d5779f53b4b06c43c35e0b94c97a112f032f9d40ea40218b8f8d11948d.jpg",
+        "image_caption": [
+            "Figure 7: Ranking stability of OSEs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            372,
+            405,
+            821,
+            655
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "(1k epoch) where the mean OS accuracy already saturates (Fig. 1), the ranking stability of top architectures is still not high (relP $@$ top $0 . 5 \\% { \\sim } 0 . 4 6 )$ . This is reasonable since that the accuracy differences between architectures in the DARTS space are smaller. And as expected, averaging the OS accuracy of multiple supernets stabilizes OSE estimations. Also, the temporal weight ensemble of multiple checkpoints can stabilize the estimations (Sec. 6.1). ",
+        "bbox": [
+            174,
+            707,
+            825,
+            776
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 How to Improve One-shot Estimations ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            526,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Since different architectures require different values for supernet parameters, as the side effect of acceleration, parameter sharing serves as the intrinsic reason for the OSE correlation gap. Appendix Fig. A15 shows the gradient similarity distribution between architecture pairs on NB201. We can see that the inter-architecture gradient similarities vary in a large range, and one common phenomenon on NB201 and NB301 is that the mean similarity between architecture pairs is lower in the middle-stage layers and the architectures’ gradients in the very first and last layers are more similar. Another slightly counterintuitive fact is that the gradient directions become more similar as the training goes on, especially on NB201. This can explain the positive transferring effect in the latter training stages. ",
+        "bbox": [
+            174,
+            827,
+            825,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Due to parameter sharing, the random sample training scheme of OSE causes estimation variances. On the other hand, improper sampling distribution causes estimation biases. There are two types ",
+        "bbox": [
+            169,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "of reasons for the bias: 1) Some architectures (e.g. with larger complexity) might need higher sampling probability to match their relative performance in standalone training. 2) Architectures are sampled from an unfair distribution, i.e., some architectures have undesirable higher equivalent probabilities. ",
+        "bbox": [
+            174,
+            155,
+            433,
+            263
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Echoing the above analysis, this section conducts case studies to improve the OSE estimations from 3 perspectives, i.e. reducing the variance, bias, and parameter sharing extent. Sec. 6.1 experiments with 2 techniques that can reduce the OS estimation variance.And in Sec. 6.2, we demonstrate that using de-isomorphic sampling in space with isomorphic architectures (NB201) helps improve the sampling fairness, thus reduce the estimation bias. ",
+        "bbox": [
+            174,
+            271,
+            433,
+            435
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b737e4b83011c839d8e9bae028ee47c8e85f8ba990ebeda34a8dfff42344abb.jpg",
+        "image_caption": [
+            "Figure 8: Effect of ensemble techniques on OSEs. Top: NB201; Bottom: NB301. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            447,
+            171,
+            820,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.1 Variance Reduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            454,
+            349,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Temporal Variance Reduction Sec. 5.3 shows that averaging OS scores of several supernets stabilizes the estimations. However, this technique is not practical due to its linearly enlarged consumption, as training k supernets takes k-times more computation. As a remedy, Guo et al. [12] propose to only train one supernet, and stabilize OS estimations by temporally averaging weights of supernet checkpoints. Besides the variance reduction effect shown in Fig. 7, Fig. 8 shows whether ensembling techniques can bring other ranking quality improvements. We can see that temporally ensembling 3 or 5 checkpoints brings improvements on NB201 but brings no bias improvements on NB301. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            577
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sampling Variance Reduction We compare the results of using different MC sample numbers $S$ in supernet training. We also adapt Fair-NAS [7] sampling strategy to NB201 and NB301. Using multiple MC architecture samples has different influences in different spaces: It is beneficial for the estimation quality on NB301, while the estimation quality on NB201 decreases slightly as the MC sample number increases. See Appendix A.3.2 for more detailed results. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            654
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6.2 Sampling Fairness Improvement ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            671,
+            439,
+            686
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Besides the complexity-level and op-level biases shown in Sec. 5.1, OSEs also have some evident architecture-level biases. The NB201 search space contains many isomorphic architectures with different representations, and there are 6466 unique structures (out of 15625) after de-isomorphism. We find that even after sufficient training, the supernet still overestimates some simple architectures significantly. Fig. 9(left) shows the top-2 ranked architectures by the average of 3 supernet’s OS scores at epoch 1000. With vanilla sampling (Iso), OS estimations bias towards simple architectures (a single Conv) with many isomorphic counterparts (Iso group size ${ } = 3 1 { }$ ). We find that this is because isomorphic architectures have identical gradients w.r.t. shared parameters, so that the shared parameters tend to be optimized towards the gradient directions of architectures with many isomorphic counterparts. ",
+        "bbox": [
+            173,
+            696,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compare the results of sampling w. or w.o. isomorphic architectures in Fig. 9(right). We can see that using the de-isomorphism (deiso) sampling strategy helps pick out top architectures and brings significant improvements on B $\\mathbf { k } @ \\mathbf { 0 . 5 } \\%$ and ${ \\bf P } @ 5 \\%$ ( $1 . 9 \\%$ to $0 . 2 3 \\%$ , $2 1 . 3 \\%$ to $4 6 . 7 \\%$ ). We also experiment with a post-de-isomorphism (post-deiso) technique, in which the estimations of architectures in an isomorphic group are averaged during testing, while no changes are made during training. We can see that “post-deiso” brings slight improvements on $\\mathrm { B R } @ \\mathrm { K s }$ and $\\mathrm { P @ }$ topKs compared with “no post-deiso”, which might owe to the decreased estimation variances. Actually, the deiso sampling strategy is to find a de-isomorphic representation space and conduct uniform sampling in it, and our study provides another evidence for the statement made by [37] that representations can be critical for NAS methods. More detailed results and discussions are in Appendix A.3.3. ",
+        "bbox": [
+            174,
+            828,
+            825,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/1527fc7344adb6fe1fb60cc8f7fc743634113c85af2a3247fb193c6f8836a989.jpg",
+        "image_caption": [
+            "Figure 9: Comparison of Iso / Deiso sampling strategy. Left: Top-2 ranked architectures when the supernet is trained with Iso / Deiso sampling strategy, the legend’s format is “OS acc $( \\% ) / \\mathrm { G T }$ acc $( \\% )$ , Iso group size”. Right: Criteria comparison along the training process. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            88,
+            823,
+            252
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            330,
+            825,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6.3 Sharing Extent Reduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            402,
+            393,
+            417
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Operation Pruning We remove one or two operations in the search space (SS) and conduct supernet training on the resulting sub-SS. After training the supernet, we compare the OS estimations on the sub-SS provided by the supernet trained on full SS and the sub-SS. The detailed results and analyses can be found in Appendix A.3.4. And the conclusion is: Sharing extent reduction by removing operations can bring improvements to the average OS scores of the remaining architectures in the sub-SS, especially in the early training stages. However, whether the improved absolute OS scores can bring ranking quality improvements is questionable, and the results vary across SSes. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            525
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "One-shot Pruning We conduct SS pruning on NB201 by selecting the top $10 \\%$ , $2 5 \\%$ , $50 \\%$ architectures ranked by the OS scores of supernet (epoch 600), and continue to finetune the supernet to 1000 epoch with these architectures. The good news is that on NB201, OS pruning brings improvements on both the average OS score and ranking quality in the sub-SS: $2 . 2 \\% / 1 . 3 \\% / 0 . 1 \\%$ average OS score increases and 0.189/0.046/0.086 KD increases when the sub-SS contains $1 0 \\% / 2 5 \\% / 5 0 \\%$ architectures, respectively. The results reveal the potential of dynamic SS pruning for improving the OSE quality, especially for good architectures. However, this per-architecture hard pruning scheme is not practical since it needs an exhaustive test of the full search space. To explore practical dynamic SS pruning methods, we conduct a case study on per-architecture soft pruning with a jointly-trained controller, where the controller gives higher sampling probability to the architectures with higher OS scores. The results and analyses are shown in Appendix A.3.4. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            684
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Remove the Affine Operation in BN We compare using or not using BN affine operations, and give out the comparison results in Appendix A.3.4. And the suggestion is that one should not use BN affine operations in the search process. ",
+        "bbox": [
+            174,
+            690,
+            821,
+            732
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "7 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            751,
+            299,
+            768
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We present an analysis framework of efficient architecture performance estimators in NAS, containing carefully developed criteria and organized analyses. Within the framework, we conduct an in-depth analysis of OSEs and ZSEs on five benchmarking search spaces with distinct properties. Our work reveals the properties, weaknesses (variance and bias) of current architecture performance estimators. For OSEs, we further conclude three directions for their improvements and experiment with several mitigations accordingly. Our work gives out suggestions for future NAS applications and points out research directions to further improve current OSEs and ZSEs. Besides the take-away knowledge, our work also provides strong baselines for future research of efficient performance estimators, and the analysis framework could be utilized to diagnose new performance estimators. ",
+        "bbox": [
+            174,
+            782,
+            825,
+            907
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            89,
+            338,
+            106
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "This work was supported by National Natural Science Foundation of China (No. U19B2019, 61832007), Tsinghua EE Xilinx AI Research Fund, Beijing National Research Center for Information Science and Technology (BNRist), and Beijing Innovation Center for Future Chips. We thank Zinan Lin, Tianchen Zhao, and Hanbo Sun for their valuable discussions. Finally, we thank all anonymous reviewers for their constructive suggestions. ",
+        "bbox": [
+            174,
+            121,
+            826,
+            190
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            210,
+            266,
+            227
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] Mohamed S. Abdelfattah, Abhinav Mehrotra, Łukasz Dudziak, and Nicholas D. Lane. ZeroCost Proxies for Lightweight NAS. In International Conference on Learning Representations, 2021.   \n[2] Bowen Baker, Otkrist Gupta, Ramesh Raskar, and Nikhil Naik. Accelerating neural architecture search using performance prediction. In International Conference on Learning Representations Workshop, 2018.   \n[3] Gabriel Bender, Pieter-Jan Kindermans, Barret Zoph, Vijay Vasudevan, and Quoc Le. Understanding and simplifying one-shot architecture search. In International Conference on Machine Learning, pages 550–559, 2018.   \n[4] Yassine Benyahia, Kaicheng Yu, Kamil Bennani Smires, Martin Jaggi, Anthony C Davison, Mathieu Salzmann, and Claudiu Musat. Overcoming multi-model forgetting. In International Conference on Machine Learning, pages 594–603. PMLR, 2019.   \n[5] Andrew Brock, Theodore Lim, James Millar Ritchie, and Nicholas J Weston. Smash: One-shot model architecture search through hypernetworks. In International Conference on Learning Representations, 2018.   \n[6] Wuyang Chen, Xinyu Gong, and Zhangyang Wang. Neural architecture search on imagenet in four gpu hours: A theoretically inspired perspective. In International Conference on Learning Representations, 2021.   \n[7] Xiangxiang Chu, Bo Zhang, Ruijun Xu, and Jixiang Li. Fairnas: Rethinking evaluation fairness of weight sharing neural architecture search. arXiv preprint arXiv:1907.01845, 2019.   \n[8] Xuanyi Dong and Yi Yang. One-shot neural architecture search via self-evaluated template network. In Proceedings of the IEEE International Conference on Computer Vision, pages 3681–3690, 2019.   \n[9] Xuanyi Dong and Yi Yang. Nas-bench-201: Extending the scope of reproducible neural architecture search. In International Conference on Learning Representations, 2020.   \n[10] Thomas Elsken, Jan Hendrik Metzen, Frank Hutter, et al. Neural architecture search: A survey. The Journal of Machine Learning Research, 20(55):1–21, 2019.   \n[11] Golnaz Ghiasi, Tsung-Yi Lin, and Quoc V Le. Nas-fpn: Learning scalable feature pyramid architecture for object detection. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 7036–7045, 2019.   \n[12] Ronghao Guo, Chen Lin, Chuming Li, Keyu Tian, Ming Sun, Lu Sheng, and Junjie Yan. Powering one-shot topological nas with stabilized share-parameter proxy. In Proceedings of the European Conference on Computer Vision, pages 625–641. Springer, 2020.   \n[13] Zichao Guo, Xiangyu Zhang, Haoyuan Mu, Wen Heng, Zechun Liu, Yichen Wei, and Jian Sun. Single path one-shot neural architecture search with uniform sampling. In Proceedings of the European Conference on Computer Vision, pages 544–560. Springer, 2020.   \n[14] Namhoon Lee, Thalaiyasingam Ajanthan, and Philip HS Torr. Snip: Single-shot network pruning based on connection sensitivity. arXiv preprint arXiv:1810.02340, 2018.   \n[15] Ming Lin, Pichao Wang, Zhenhong Sun, Hesen Chen, Xiuyu Sun, Qi Qian, Hao Li, and Rong Jin. Zen-nas: A zero-shot nas for high-performance deep image recognition. In Proceedings of the IEEE International Conference on Computer Vision, pages 347–356, 2021.   \n[16] Hanxiao Liu, Karen Simonyan, and Yiming Yang. Darts: Differentiable architecture search. arXiv preprint arXiv:1806.09055, 2018.   \n[17] Vasco Lopes, Saeid Alirezazadeh, and Luís A Alexandre. Epe-nas: Efficient performance estimation without training for neural architecture search. arXiv preprint arXiv:2102.08099, 2021.   \n[18] Renqian Luo, Tao Qin, and Enhong Chen. Balanced one-shot neural architecture optimization. arXiv preprint arXiv:1909.10815, 2019.   \n[19] Renqian Luo, Fei Tian, Tao Qin, Enhong Chen, and Tie-Yan Liu. Neural architecture optimization. In Advances in Neural Information Processing Systems, pages 7816–7827. 2018.   \n[20] Joseph Mellor, Jack Turner, Amos Storkey, and Elliot J. Crowley. Neural architecture search without training. arXiv preprint arXiv:2006.04647, 2021.   \n[21] Joseph Mellor, Jack Turner, Amos Storkey, and Elliot J. Crowley. Neural architecture search without training. In International Conference on Machine Learning, 2021.   \n[22] Michael C Mozer and Paul Smolensky. Skeletonization: A technique for trimming the fat from a network via relevance assessment. In Advances in Neural Information Processing Systems, pages 107–115, 1989.   \n[23] Niv Nayman, Asaf Noy, Tal Ridnik, Itamar Friedman, Rong Jin, and Lihi Zelnik. Xnas: Neural architecture search with expert advice. Advances in Neural Information Processing Systems, 32:1977–1987, 2019.   \n[24] Xuefei Ning, Changcheng Tang, Wenshuo Li, Songyi Yang, Tianchen Zhao, Niansong Zhang, Tianyi Lu, Shuang Liang, Huazhong Yang, and Yu Wang. aw_nas: A modularized and extensible nas framework. arXiv preprint arXiv:2012.10388, 2020.   \n[25] Xuefei Ning, Yin Zheng, Tianchen Zhao, Yu Wang, and Huazhong Yang. A generic graph-based neural architecture encoding scheme for predictor-based nas. In Proceedings of the European Conference on Computer Vision, 2020.   \n[26] Daniel S Park, Jaehoon Lee, Daiyi Peng, Yuan Cao, and Jascha Sohl-Dickstein. Towards nngp-guided neural architecture search. arXiv preprint arXiv:2011.06006, 2020.   \n[27] Hieu Pham, Melody Guan, Barret Zoph, Quoc Le, and Jeff Dean. Efficient neural architecture search via parameters sharing. In International Conference on Machine Learning, pages 4095–4104. PMLR, 2018.   \n[28] Aloïs Pourchot, Alexis Ducarouge, and Olivier Sigaud. To share or not to share: A comprehensive appraisal of weight-sharing. arXiv preprint arXiv:2002.04289, 2020.   \n[29] Ilija Radosavovic, Justin Johnson, Saining Xie, Wan-Yen Lo, and Piotr Dollár. On network design spaces for visual recognition. In Proceedings of the IEEE International Conference on Computer Vision, pages 1882–1890, 2019.   \n[30] Esteban Real, Alok Aggarwal, Yanping Huang, and Quoc V Le. Regularized evolution for image classifier architecture search. In Proceedings of the aaai conference on artificial intelligence, volume 33, pages 4780–4789, 2019.   \n[31] Binxin Ru, Clare Lyle, Lisa Schut, Miroslav Fil, Mark van der Wilk, and Yarin Gal. Speedy performance estimation for neural architecture search, 2021.   \n[32] Julien Siems, Lucas Zimmer, Arber Zela, Jovita Lukasik, Margret Keuper, and Frank Hutter. Nas-bench-301 and the case for surrogate benchmarks for neural architecture search. arXiv preprint arXiv:2008.09777, 2020.   \n[33] Hidenori Tanaka, Daniel Kunin, Daniel LK Yamins, and Surya Ganguli. Pruning neural networks without any data by iteratively conserving synaptic flow. arXiv preprint arXiv:2006.05467, 2020.   \n[34] Lucas Theis, Iryna Korshunova, Alykhan Tejani, and Ferenc Huszár. Faster gaze prediction with dense networks and fisher pruning. arXiv preprint arXiv:1801.05787, 2018.   \n[35] Jack Turner, Elliot J Crowley, Michael O’Boyle, Amos Storkey, and Gavin Gray. Blockswap: Fisher-guided block substitution for network compression on a budget. arXiv preprint arXiv:1906.04113, 2019.   \n[36] Chaoqi Wang, Guodong Zhang, and Roger Grosse. Picking winning tickets before training by preserving gradient flow. arXiv preprint arXiv:2002.07376, 2020.   \n[37] Colin White, Willie Neiswanger, Sam Nolen, and Yash Savani. A study on encodings for neural architecture search. Advances in Neural Information Processing Systems, 2020.   \n[38] Colin White, Arber Zela, Binxin Ru, Yang Liu, and Frank Hutter. How powerful are performance predictors in neural architecture search? arXiv preprint arXiv:2104.01177, 2021.   \n[39] Bichen Wu, Xiaoliang Dai, Peizhao Zhang, Yanghan Wang, Fei Sun, Yiming Wu, Yuandong Tian, Peter Vajda, Yangqing Jia, and Kurt Keutzer. Fbnet: Hardware-aware efficient convnet design via differentiable neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 10734–10742, 2019.   \n[40] Zhaohui Yang, Yunhe Wang, Xinghao Chen, Boxin Shi, Chao Xu, Chunjing Xu, Qi Tian, and Chang Xu. Cars: Continuous evolution for efficient neural architecture search. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 1829–1838, 2020.   \n[41] Chris Ying, Aaron Klein, Eric Christiansen, Esteban Real, Kevin Murphy, and Frank Hutter. Nas-bench-101: Towards reproducible neural architecture search. In International Conference on Machine Learning, pages 7105–7114. PMLR, 2019.   \n[42] Kaicheng Yu, René Ranftl, and Mathieu Salzmann. How to train your super-net: An analysis of training heuristics in weight-sharing NAS. abs/2003.04276, 2020.   \n[43] Kaicheng Yu, Christian Sciuto, Martin Jaggi, Claudiu Musat, and Mathieu Salzmann. Evaluating the search phase of neural architecture search. In International Conference on Learning Representations, 2020.   \n[44] Arber Zela, Julien Siems, and Frank Hutter. Nas-bench-1shot1: Benchmarking and dissecting one-shot neural architecture search. In International Conference on Learning Representations, 2020.   \n[45] Chris Zhang, Mengye Ren, and Raquel Urtasun. Graph hypernetworks for neural architecture search. In International Conference on Learning Representations, 2019.   \n[46] Miao Zhang, Huiqi Li, Shirui Pan, Xiaojun Chang, and Steven Su. Overcoming multi-model forgetting in one-shot nas with diversity maximization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2020.   \n[47] Yuge Zhang, Zejun Lin, Junyang Jiang, Quanlu Zhang, Yujing Wang, Hui Xue, Chen Zhang, and Yaming Yang. Deeper insights into weight sharing in neural architecture search. arXiv preprint arXiv:2001.01431, 2020.   \n[48] Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. In International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            178,
+            233,
+            826,
+            915
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            56,
+            828,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            79,
+            828,
+            561
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HklXn1BKDH/HklXn1BKDH.md

@@ -0,0 +1,378 @@
+# LEARNING TO EXPLORE USING ACTIVE NEURAL SLAM
+
+Devendra Singh Chaplot1†, Dhiraj Gandhi2, Saurabh Gupta3∗, Abhinav Gupta 1,2∗, Ruslan Salakhutdinov1∗ 1Carnegie Mellon University, 2Facebook AI Research, 3UIUC
+
+Project webpage: https://devendrachaplot.github.io/projects/Neural-SLAM Code: https://github.com/devendrachaplot/Neural-SLAM
+
+# ABSTRACT
+
+This work presents a modular and hierarchical approach to learn policies for exploring 3D environments, called ‘Active Neural SLAM’. Our approach leverages the strengths of both classical and learning-based methods, by using analytical path planners with learned SLAM module, and global and local policies. The use of learning provides flexibility with respect to input modalities (in the SLAM module), leverages structural regularities of the world (in global policies), and provides robustness to errors in state estimation (in local policies). Such use of learning within each module retains its benefits, while at the same time, hierarchical decomposition and modular training allow us to sidestep the high sample complexities associated with training end-to-end policies. Our experiments in visually and physically realistic simulated 3D environments demonstrate the effectiveness of our approach over past learning and geometry-based approaches. The proposed model can also be easily transferred to the PointGoal task and was the winning entry of the CVPR 2019 Habitat PointGoal Navigation Challenge.
+
+# 1 INTRODUCTION
+
+Navigation is a critical task in building intelligent agents. Navigation tasks can be expressed in many forms, for example, point goal tasks involve navigating to specific coordinates and semantic navigation involves finding the path to a specific scene or object. Irrespective of the task, a core problem for navigation in unknown environments is exploration, i.e., how to efficiently visit as much of the environment. This is useful for maximizing the coverage to give the best chance of finding the target in unknown environments or for efficiently pre-mapping environments on a limited time-budget.
+
+Recent work from Chen et al. (2019) has used end-to-end learning to tackle this problem. Their motivation is three-fold: a) learning provides flexibility to the choice of input modalities (classical systems rely on observing geometry through the use of specialized sensors, while learning systems can infer geometry directly from RGB images), $b$ ) use of learning can improve robustness to errors in explicit state estimation, and $c _ { . }$ ) learning can effectively leverage structural regularities of the real world, leading to more efficient behavior in previously unseen environments. This lead to their design of an end-to-end trained neural network-based policy that processed raw sensory observations to directly output actions that the agent should execute.
+
+While the use of learning for exploration is well-motivated, casting the exploration problem as an end-to-end learning problem has its own drawbacks. Learning about mapping, state-estimation, and path-planning purely from data in an end-to-end manner can be prohibitively expensive. Consequently, past end-to-end learning work for exploration from Chen et al. (2019) relies on the use of imitation learning and many millions of frames of experience, but still performs worse than classical methods that don’t require any training at all.
+
+This motivates our work. In this paper, we investigate alternate formulations of employing learning for exploration that retains the advantages that learning has to offer, but doesn’t suffer from the drawbacks of full-blown end-to-end learning. Our key conceptual insight is that use of learning for leveraging structural regularities of indoor environments, robustness to state-estimation errors, and flexibility with respect to input modalities, happens at different time scales and can thus be factored out. This motivates the use of learning in a modular and hierarchical fashion inside of what one may call a ‘classical navigation pipeline’. This results in navigation policies that can work with raw sensory inputs such as RGB images, are robust to state estimation errors, and leverage the regularities of real-world layouts. This results in extremely competitive performance over both geometry-based methods and recent learning-based methods; at the same time requiring a fraction of the number of samples.
+
+More specifically, our proposed exploration architecture comprises of a learned Neural SLAM module, a global policy, and a local policy, that are interfaced via the map and an analytical path planner. The learned Neural SLAM module produces free space maps and estimates agent pose from input RGB images and motion sensors. The global policy consumes this free-space map with the agent pose and employs learning to exploit structural regularities in layouts of real-world environments to produce long-term goals. These long-term goals are used to generate short-term goals for the local policy (using a geometric path-planner). This local policy uses learning to directly map raw RGB images to actions that the agent should execute. Use of learning in the SLAM module provides flexibility with respect to input modality, learned global policy can exploit regularities in layouts of real-world environments, while learned local policies can use visual feedback to exhibit more robust behavior. At the same time, hierarchical and modular design and use of analytical planning, significantly cuts down the search space during training, leading to better performance as well as sample efficiency.
+
+We demonstrate our proposed approach in visually and physically realistic simulators for the task of geometric exploration (visit as much area as possible). We work with the Habitat simulator from Savva et al. (2019). While Habitat is already visually realistic (it uses real-world scans from Chang et al. (2017) and Xia et al. (2018) as environments), we improve its physical realism by using actuation and odometry sensor noise models, that we collected by conducting physical experiments on a real mobile robot. Our experiments and ablations in this realistic simulation reveal the effectiveness of our proposed approach for the task of exploration. A straightforward modification of our method also tackles point-goal navigation tasks, and won the AI Habitat challenge at CVPR2019 across all tracks.
+
+# 2 RELATED WORK
+
+Navigation has been well studied in classical robotics. There has been a renewed interest in the use of learning to arrive at navigation policies, for a variety of tasks. Our work builds upon concepts in classical robotics and learning for navigation. We survey related works below.
+
+Navigation Approaches. Classical approaches to navigation break the problem into two parts: mapping and path planning. Mapping is done via simultaneous localization and mapping (Thrun et al., 2005; Hartley and Zisserman, 2003; Fuentes-Pacheco et al., 2015), by fusing information from multiple views of the environment. While sparse reconstruction can be done well with monocular RGB images (Mur-Artal and Tardós, 2017), dense mapping is inefficient (Newcombe et al., 2011) or requires specialized scanners such as Kinect (Izadi et al., 2011). Maps are used to compute paths to goal locations via path planning (Kavraki et al., 1996; Lavalle and Kuffner Jr, 2000; Canny, 1988). These classical methods have inspired recent learning-based techniques. Researchers have designed neural network policies that reason via spatial representations (Gupta et al., 2017; Parisotto and Salakhutdinov, 2018; Zhang et al., 2017; Henriques and Vedaldi, 2018; Gordon et al., 2018), topological representations (Savinov et al., 2018; 2019), or use differentiable and trainable planners (Tamar et al., 2016; Lee et al., 2018; Gupta et al., 2017; Khan et al., 2017). Our work furthers this research, and we study a hierarchical and modular decomposition of the problem and employ learning inside these components instead of end-to-end learning. Research also focuses on incorporating semantics in SLAM (Pronobis and Jensfelt, 2012; Walter et al., 2013).
+
+Exploration in Navigation. While a number of works focus on passive map-building, path planning and goal-driven policy learning, a much smaller body of work tackles the the problem of active SLAM, i.e., how to actively control the camera for map building. We point readers to FuentesPacheco et al. (2015) for a detailed survey, and summarize the major themes below. Most such works frame this problem as a Partially Observable Markov Decision Process (POMDP) that are approximately solved (Martinez-Cantin et al., 2009; Kollar and Roy, 2008), and or seek to find a sequence of actions that minimizes uncertainty of maps (Stachniss et al., 2005; Carlone et al., 2014).
+
+Another line of work explores by picking vantage points (such as on the frontier between explored and unexplored regions (Dornhege and Kleiner, 2013; Holz et al., 2010; Yamauchi, 1997; Xu et al., 2017)). Recent works from Chen et al. (2019); Savinov et al. (2019); Fang et al. (2019) attack this problem via learning. Our proposed modular policies unify the last two lines of research, and we show improvements over representative methods from both these lines of work. Exploration has also been studied more generally in RL in the context of exploration-exploitation trade-off (Sutton and Barto, 2018; Kearns and Singh, 2002; Auer, 2002; Jaksch et al., 2010).
+
+Hierarchical and Modular Policies. Hierarchical RL (Dayan and Hinton, 1993; Sutton et al., 1999; Barto and Mahadevan, 2003) is an active area of research, aimed at automatically discovering hierarchies to speed up learning. However, this has proven to be challenging, and thus most work has resorted to using hand-defining hierarchies. For example in the context of navigation, Bansal et al. (2019) and Kaufmann et al. (2019) design modular policies for navigation, that interface learned policies with low-level feedback controllers. Hierarchical and modular policies have also been used for Embodied Question Answering (Das et al., 2018a; Gordon et al., 2018; Das et al., 2018b).
+
+# 3 TASK SETUP
+
+We follow the exploration task setup proposed by Chen et al. (2019) where the objective is to maximize the coverage in a fixed time budget. The coverage is defined as the total area in the map known to be traversable. Our objective is to train a policy which takes in an observation $s _ { t }$ at each time step $t$ and outputs a navigational action $a _ { t }$ to maximize the coverage.
+
+We try to make our experimental setup in simulation as realistic as possible with the goal of transferring trained policies to the real world. We use the Habitat simulator (Savva et al., 2019) with the Gibson (Xia et al., 2018) and Matterport (MP3D) (Chang et al., 2017) datasets for our experiments. Both Gibson and Matterport datasets are based on real-world scene reconstructions are thus significantly more realistic than synthetic SUNCG dataset (Song et al., 2017) used for past research on exploration (Chen et al., 2019; Fang et al., 2019).
+
+In addition to synthetic scenes, prior works on learning-based navigation have also assumed simplistic agent motion. Some works limit agent motion on a grid with 90 degree rotations (Zhu et al., 2017; Gupta et al., 2017; Chaplot et al., 2018). Other works which implement fine-grained control, typically assume unrealistic agent motion with no noise (Savva et al., 2019) or perfect knowledge of agent pose (Chaplot et al., 2016). Since the motion is simplistic, it becomes trivial to estimate the agent pose in most cases even if it is not assumed to be known. The reason behind these assumptions on agent motion and pose is that motion and sensor noise models are not known. In order to relax both these assumptions, we collect motion and sensor data in the real-world and implement more realistic agent motion and sensor noise models in the simulator as described in the following subsection.
+
+# 3.1 ACTUATION AND SENSOR NOISE MODEL
+
+We represent the agent pose by $( x , y , o )$ where $x$ and $y$ represent the xy co-ordinate of the agent measured in metres and $o$ represents the orientation of the agent in radians (measured counterclockwise from $x$ -axis). Without loss of generality, assume agents starts at $p _ { 0 } = ( 0 , 0 , 0 )$ . Now, suppose the agent takes an action $a _ { t }$ . Each action is implemented as a control command on a robot. Let the corresponding control command be $\Delta u _ { a } = ( x _ { a } , y _ { a } , o _ { a } )$ . Let the agent pose after the action be $p _ { 1 } = \left( x ^ { \star } , y ^ { \star } , o ^ { \star } \right)$ . The actuation noise $( \epsilon _ { a c t } )$ is the difference between the actual agent pose $( p _ { 1 } )$ after the action and the intended agent pose $( p _ { 0 } + \Delta u )$ :
+
+$$
+\epsilon _ { a c t } = p _ { 1 } - ( p _ { 0 } + \Delta u ) = ( x ^ { \star } - x _ { a } , y ^ { \star } - y _ { a } , o ^ { \star } - o _ { a } )
+$$
+
+Mobile robots typically have sensors which estimate the robot pose as it moves. Let the sensor estimate of the agent pose after the action be $p _ { 1 } ^ { \prime } = ( x ^ { \prime } , y ^ { \prime } , o ^ { \prime } )$ . The sensor noise $( \epsilon _ { s e n } )$ is given by the difference between the sensor pose estimate $( p _ { 1 } ^ { \prime } )$ and the actual agent pose $( p _ { 1 } )$ :
+
+$$
+\epsilon _ { s e n } = p _ { 1 } ^ { \prime } - p _ { 1 } = ( x ^ { \prime } - x ^ { \star } , y ^ { \prime } - y ^ { \star } , o ^ { \prime } - o ^ { \star } )
+$$
+
+In order to implement the actuation and sensor noise models, we would like to collect data for navigational actions in the Habitat simulator. We use three default navigational actions: Forward: move forward by $2 5 \mathrm { c m }$ , Turn Right: on the spot rotation clockwise by 10 degrees, and Turn Left: on the spot rotation counter-clockwise by 10 degrees. The control commands are implemented as $u _ { F o r w a r d } = ( 0 . 2 5 , 0 , 0 )$ , $u _ { R i g h t } : ( 0 , 0 , - 1 0 * \pi / 1 8 0 )$ and $u _ { L e f t } : ( 0 , 0 , 1 0 * \pi / 1 8 0 )$ . In practice, a robot can also rotate slightly while moving forward and translate a bit while rotating on-the-spot, creating rotational actuation noise in forward action and similarly, a translation actuation noise in on-the-spot rotation actions.
+
+![](images/0f828ac8d8031ec900e14da185f239abeaa1db5f7b3cc2e5cecbd62ba773fdd1.jpg)  
+Figure 1: Overview of our approach. The Neural SLAM module predicts a map and agent pose estimate from incoming RGB observations and sensor readings. This map and pose are used by a Global policy to output a long-term goal, which is converted to a short-term goal using an analytic path planner. A Local Policy is trained to navigate to this short-term goal.
+
+We use a LoCoBot1 to collect data for building the actuation and sensor noise models. We use the pyrobot API (Murali et al., 2019) along with ROS (Quigley et al., 2009) to implement the control commands and get sensor readings. For each action $a$ , we fit a separate Gaussian Mixture Model for the actuation noise and sensor noise, making a total of 6 models. Each component in these Gaussian mixture models is a multi-variate Gaussian in 3 variables, $x , y$ and $o$ . For each model, we collect 600 datapoints. The number of components in each Gaussian mixture model is chosen using cross-validation. We implement these actuation and sensor noise models in the Habitat simulator for our experiments. We have released the noise models, along with their implementation in the Habitat simulator in the open-source code.
+
+# 4 METHODS
+
+We propose a modular navigation model, ‘Active Neural SLAM’. It consists of three components: a Neural SLAM module, a Global policy and a Local policy as shown in Figure 1. The Neural SLAM module predicts the map of the environment and the agent pose based on the current observations and previous predictions. The Global policy uses the predicted map and agent pose to produce a long-term goal. The long-term goal is converted into a short-term goal using path planning. The Local policy takes navigational actions based on the current observation to reach the short-term goal.
+
+Map Representation. The Active Neural SLAM model internally maintains a spatial map, $m _ { t }$ and pose of the agent $x _ { t }$ . The spatial map, $m _ { t }$ , is a $2 \times M \times M$ matrix where $M \times M$ denotes the map size and each element in this spatial map corresponds to a cell of size $2 5 c m ^ { 2 }$ $( 5 c m \times 5 c m )$ in the physical world. Each element in the first channel denotes the probability of an obstacle at the corresponding location and each element in the second channel denotes the probability of that location being explored. A cell is considered to be explored when it is known to be free space or an obstacle. The spatial map is initialized with all zeros at the beginning of an episode, $m _ { 0 } = [ \dot { 0 } ] ^ { 2 \times M \times M }$ The pose $\boldsymbol { x } _ { t } \in { \mathbb { R } } ^ { 3 }$ denotes the $x$ and $y$ coordinates of the agent and the orientation of the agent at time $t$ . The agent always starts at the center of the map facing east at the beginning of the episode, $x _ { 0 } = ( M / 2 , \bar { M } / 2 , 0 . 0 ) $ .
+
+Neural SLAM Module. The Neural SLAM Module $( f _ { S L A M } )$ takes in the current RGB observation, $s _ { t }$ , the current and last sensor reading of the agent pose $x _ { t - 1 : t } ^ { \prime }$ , last agent pose and map estimates, $\hat { x } _ { t - 1 } , m _ { t - 1 }$ and outputs an updated map, $m _ { t }$ , and the current agent pose estimate, $\hat { x } _ { t }$ , (see Figure 2): $m _ { t } , \hat { x } _ { t } = f _ { S L A M } ( s _ { t } , x _ { t - 1 : t } ^ { \prime } , \hat { x } _ { t - 1 } , \bar { m } _ { t - 1 } | \theta _ { S } )$ , where $\theta _ { S }$ denote the trainable parameters of the Neural SLAM module. It consists of two learned components, a Mapper and a Pose Estimator. The Mapper $( f _ { M a p } )$ outputs a egocentric top-down 2D spatial map, $p _ { t } ^ { e \dot { g } \dot { o } } \in [ 0 , 1 ] ^ { 2 \times V \times V }$ (where $V$ is the vision range), predicting the obstacles and the explored area in the current observation. The Pose Estimator $( f _ { P E } )$ predicts the agent pose $( \hat { x } _ { t } )$ based on past pose estimate $( \hat { x } _ { t - 1 } )$ and last two egocentric map predictions $( p _ { t - 1 : t } ^ { e g o } )$ . It essentially compares the current egocentric map prediction to the last egocentric map prediction transformed to the current frame to predict the pose change between the two maps. The egocentric map from the Mapper is transformed to a geocentric map based on the pose estimate given by the Pose Estimator and then aggregated with the previous spatial map $( m _ { t - 1 } )$ to get the current map $( m _ { t } )$ . More implementation details of the Neural SLAM module are provided in the Appendix.
+
+![](images/b80248233673c08cd64375a78fcf41addfd6f1f25c6dd5da99331d4bcce81b71.jpg)  
+Figure 2: Architecture of the Neural SLAM module: The Neural SLAM module $( f _ { M a p } )$ takes in the current RGB observation, $s _ { t }$ , the current and last sensor reading of the agent pose $x _ { t - 1 : t } ^ { \prime }$ , last agent pose estimate, $\hat { x } _ { t - 1 }$ and the map at the previous time step $m _ { t - 1 }$ and outputs an updated map, $m _ { t }$ and the current agent pose estimate, $\hat { x } _ { t }$ . ‘ST’ denotes spatial transformation.
+
+Global Policy. The Global Policy takes $h _ { t } \in [ 0 , 1 ] ^ { 4 \times M \times M }$ as input, where the first two channels of $h _ { t }$ are the spatial map $m _ { t }$ given by the SLAM module, the third channel represents the current agent position estimated by the SLAM module, the fourth channel represents the visited locations, i.e. $\bar { \forall i } , j \in \{ 1 , 2 , \dots , m \}$ :
+
+$$
+\begin{array} { r l } & { h _ { t } [ c , i , j ] = m _ { t } [ c , i , j ] \quad \forall c \in \{ 0 , 1 \} } \\ & { h _ { t } [ 2 , i , j ] = 1 \qquad } & { \mathrm { i f ~ } i = \hat { x } _ { t } [ 0 ] \mathrm { ~ a n d ~ } j = \hat { x } _ { t } [ 1 ] } \\ & { h _ { t } [ 3 , i , j ] = 1 \qquad } & { \mathrm { i f ~ } ( i , j ) \in [ ( \hat { x } _ { k } [ 0 ] , \hat { x } _ { k } [ 1 ] ) ] _ { k \in \{ 0 , 1 , \ldots , t \} } } \end{array}
+$$
+
+We perform two transformations before passing $h _ { t }$ to the Global Policy model. The first transformation subsamples a window of size $4 \times G \times G$ around the agent from $h _ { t }$ . The second transformation performs max pooling operations to get an output of size $4 \times G \times G$ from $h _ { t }$ . Both the transformations are stacked to form a tensor of size $8 \times G \times G$ and passed as input to the Global Policy model. The Global Policy uses a convolutional neural network to predict a long-term goal, $g _ { t } ^ { l }$ in $G \times G$ space: $g _ { t } ^ { l } = \pi _ { G } ( h _ { t } | \dot { \theta } _ { G } )$ , where $\theta _ { G }$ are the parameters of the Global Policy.
+
+Planner. The Planner takes the long-term goal $( g _ { t } ^ { l } )$ , the spatial obstacle map $( m _ { t } )$ and the agnet pose estimate $( \hat { x } _ { t } )$ as input and computes the short-term goal $g _ { t } ^ { s }$ , i.e. $g _ { t } ^ { s } = f _ { P l a n } ( g _ { t } ^ { l } , m _ { t } , \hat { x } _ { t } )$ . It computes the shortest path from the current agent location to the long-term goal $( g _ { t } ^ { l } )$ using the Fast Marching Method (Sethian, 1996) based on the current spatial map $m _ { t }$ . The unexplored area is considered as free space for planning. We compute a short-term goal coordinate (farthest point within $d _ { s } ( = 0 . 2 5 m )$ from the agent) on the planned path.
+
+Local Policy. The Local Policy takes as input the current RGB observation $\left( { { s _ { t } } } \right)$ and the short-term goal $( g _ { t } ^ { s } )$ and outputs a navigational action, $a _ { t } = \pi _ { L } ( s _ { t } , g _ { t } ^ { s } | \theta _ { L } )$ , where $\theta _ { L }$ are the parameters of the Local Policy. The short-term goal coordinate is transformed into relative distance and angle from the agent’s location before being passed to the Local Policy. The Local Policy is a recurrent neural network consisting of a pretrained ResNet18 (He et al., 2016) as the visual encoder.
+
+# 5 EXPERIMENTAL SETUP
+
+We use the Habitat simulator (Savva et al., 2019) with the Gibson (Xia et al., 2018) and Matterport (MP3D) (Chang et al., 2017) datasets for our experiments. Both Gibson and MP3D consist of scenes which are 3D reconstructions of real-world environments, however, Gibson is collected using a different set of cameras, consists mostly of office spaces while MP3D consists of mostly homes with a larger average scene area. We will use Gibson as our training domain, and use MP3D for domain generalization experiments. The observation space consists of RGB images of size $3 \times 1 2 8 \times 1 2 8$ and base odometry sensor readings of size $3 \times 1$ denoting the change in agent’s x-y coordinates and orientation. The actions space consists of three actions: move_forward, turn_left, turn_right. Both the base odometry sensor readings and the agent motion based on the actions are noisy. They are implemented using the sensor and actuation noise models based on real-world data as discussed in Section 3.1.
+
+We follow the Exploration task setup proposed by Chen et al. (2019) where the objective to maximize the coverage in a fixed time budget. Coverage is the total area in the map known to be traversable. We define a traversable point to be known if it is in the field-of-view of the agent and is less than $3 . 2 m$ away. We use two evaluation metrics, the absolute coverage area in $m ^ { 2 }$ (Cov) and the percentage of area explored in the scene ( $\%$ Cov), i.e. ratio of coverage to maximum possible coverage in the corresponding scene. During training, each episode lasts for a fixed length of 1000 steps.
+
+We use train/val/test splits provided by Savva et al. (2019) for both the datasets. Note that the set of scenes used in each split is disjoint, which means the agent is tested on new scenes never seen during training. Gibson test set is not public but rather held out on an online evaluation server for the Pointgoal task. We use the validation as the test set for comparison and analysis for the Gibson domain. We do not use the validation set for hyper-parameter tuning. To analyze the performance of all the models with respect to the size of the scene, we split the Gibson validation set into two parts, a small set of 10 scenes with explorable area ranging from $1 6 m ^ { 2 }$ to $3 6 m ^ { 2 }$ , and a large set of 4 scenes with explorable area ranging from $5 5 m ^ { 2 }$ to $1 0 \hat { 0 } m ^ { 2 }$ . Note that the size of the map is usually much larger than the traversable area, with the largest map being about $2 3 m$ long and $1 1 m$ wide.
+
+Training Details. We train our model in the Gibson domain and transfer it to the Matterport domain. The Mapper is trained to predict egocentric projections, and the Pose Estimator is trained to predict agent pose using supervised learning. The ground truth egocentric projection is computed using geometric projections from ground truth depth. The Global Policy is trained using Reinforcement Learning with reward proportional to the increase in coverage as the reward. The Local Policy is trained using Imitation Learning (behavioral cloning). All the modules are trained simultaneously. Their parameters are independent, but the data distribution is inter-dependent. Based on the actions taken by the Local policy, the future input to Neural SLAM module changes, which in turn changes the map and agent pose input to the Global policy and consequently affects the short-term goal given to the Local Policy. For more architecture and hyperparameter details, please refer to the supplementary material and the open-source code.
+
+Baselines. We use a range of end-to-end Reinforcement Learning (RL) methods as baselines:
+
+RL $^ +$ 3LConv: An RL Policy with 3 layer convolutional network followed by a GRU (Cho et al., 2014) as described by Savva et al. (2019).
+
+$\mathbf { R L } + \mathbf { R e s } \mathbf { 1 8 }$ : A RL Policy initialized with ResNet18 (He et al., 2016) pre-trained on ImageNet followed by a GRU.
+
+$\mathbf { R L } + \mathbf { R e s 1 8 } +$ AuxDepth: This baseline is adapted from Mirowski et al. (2017) who use depth prediction as an auxiliary task. We use the same architecture as our Neural SLAM module (conv layers from ResNet18) with one additional deconvolutional layer for Depth prediction followed by 3 layer convolution and GRU for the policy.
+
+$\mathbf { R L } + \mathbf { R e s 1 8 } + \mathbf { P r }$ ojDepth: This baseline is adapted form Chen et al. (2019) who project the depth image in an egocentric top-down in addition to the RGB image as input to the RL policy. Since we do not have depth as input, we use the architecture from $\mathrm { R L } + \mathrm { R e s } 1 8 +$ AuxDepth for depth prediction and project the predicted depth before passing to 3Layer Conv and GRU policy.
+
+For all the baselines, we also feed a 32-dimensional embedding of the sensor pose reading to the GRU along with the image-based representation. This embedding is also learnt end-to-end using RL. All baselines are trained using PPO (Schulman et al., 2017) with increase in coverage as the reward (identical to the reward used for Global policy). All the baselines require access to the ground-truth map during training for computing the reward. The supervision for the Global Policy, the Local Policy and the Mapper can also be obtained from the ground-truth map. The Pose Estimator requires additional supervision in the form of the ground-truth agent pose. We study the effect of this additional supervision in ablation experiments.
+
+Table 1: Exploration performance of the proposed model, Active Neural SLAM (ANS) and baselines. The baselines are adated from [1] Savva et al. (2019), [2] Mirowski et al. (2017) and [3] Chen et al. (2019).   
+
+<table><tr><td></td><td colspan="2">Gibson Val</td><td colspan="2">Domain Generalization MP3D Test</td></tr><tr><td>Method</td><td>% Cov.</td><td>Cov. (m2)</td><td>% Cov.</td><td>Cov. (m2)</td></tr><tr><td>RL + 3LConv [1]</td><td>0.737</td><td>22.838</td><td>0.332</td><td>47.758</td></tr><tr><td>RL + Res18</td><td>0.747</td><td>23.188</td><td>0.341</td><td>49.175</td></tr><tr><td>RL + Res18 + AuxDepth [2]</td><td>0.779</td><td>24.467</td><td>0.356</td><td>51.959</td></tr><tr><td>RL + Res18 +ProjDepth [3]</td><td>0.789</td><td>24.863</td><td>0.378</td><td>54.775</td></tr><tr><td>Active Neural SLAM (ANS)</td><td>0.948</td><td>32.701</td><td>0.521</td><td>73.281</td></tr></table>
+
+![](images/97cf4af8c9e15b2b94848570a8a3140c5bf776534ac2e16e96b117b44c81d4be.jpg)  
+Figure 3: Plot showing the $\%$ Coverage as the episode progresses for ANS and the baselines on the large and small scenes in the Gibson Val set as well as the overall Gibson Val set.
+
+# 6 RESULTS
+
+We train the proposed ANS model and all the baselines for the Exploration task with 10 million frames on the Gibson training set. The results are shown in Table 1. The results on the Gibson Val set are averaged over a total of 994 episodes in 14 different unseen scenes. The proposed model achieves an average absolute and relative coverage of $3 2 . 7 0 1 m ^ { 2 } / 0 . 9 4 8$ as compared to $2 4 . 8 6 3 m ^ { 2 } / 0 . 7 8 9$ for the best baseline. This indicates that the proposed model is more efficient and effective at exhaustive exploration as compared to the baselines. This is because our hierarchical policy architecture reduces the horizon of the long-term exploration problem as instead of taking tens of low-level navigational actions, the Global policy only takes few long-term goal actions. We also report the domain generalization performance on the Exploration task in Table 1 (see shaded region), where all models trained on Gibson are evaluated on the Matterport domain. ANS leads to higher domain generalization performance $( 7 3 . 2 8 1 m ^ { 2 } / 0 . 5 2 1$ vs $5 4 . 7 7 5 \bar { m ^ { 2 } } / 0 . 3 7 8 )$ . The absolute coverage is higher and $\%$ Cov is lower for the Matterport domain as it consists of larger scenes on average. On a set of small MP3D test scenes (comparable to Gibson scene sizes), ANS achieved a performance of $3 1 . 4 0 7 m ^ { 2 } / 0 . 8 3 6$ as compared to $\dot { 2 } 3 . 0 9 1 m ^ { 2 } / 0 . 6 2 0$ for the best baseline. Some visualizations of policy execution are provided in Figure $4 ^ { 2 }$ .
+
+In Fig. 3, we plot the relative coverage $( \% \thinspace \mathrm { C o v } )$ of all the models as the episode progresses on the large and small scene sets, as well as the overall Gibson Val set. The plot on the small scene set shows that ANS is able to almost completely explore the small scenes in around 500 steps, however, the baselines are only able to explore $8 5 - 9 0 \%$ of the small scenes in 1000 steps (see Fig. 3 center). This indicates that ANS explores more efficiently in small scenes. The plot on the large scenes set shows that the performance gap between ANS and baselines widens as the episode progresses (see Fig. 3 left). Looking at the behavior of the baselines, we saw that they often got stuck in local areas. This behavior indicates that they are unable to remember explored areas over long-time horizons and are ineffective at long-term planning. On the other hand, ANS uses a Global policy on the map which allows it to have the memory of explored areas over long-time horizons, and plan effectively to reach distant long-term goals by leveraging analytical planners. As a result, it is able to explore effectively in large scenes with long episode lengths.
+
+Table 2: Results of the ablation experiments on the Gibson environment.   
+Time   
+
+<table><tr><td>Method</td><td colspan="2">Gibson Val Overall</td><td colspan="2">Gibson Val Large</td><td colspan="2">Gibson Val Small</td></tr><tr><td></td><td>% Cov.</td><td>Cov. (m2)</td><td>% Cov.</td><td>Cov. (m2)</td><td>% Cov.</td><td>Cov. (m2)</td></tr><tr><td>ANS w/o Local Policy + Det. Planner</td><td>0.941</td><td>32.188</td><td>0.845</td><td>53.999</td><td>0.980</td><td>23.464</td></tr><tr><td>ANS w/o Global Policy+FBE</td><td>0.925</td><td>30.981</td><td>0.782</td><td>49.731</td><td>0.982</td><td>23.481</td></tr><tr><td>ANS w/o Pose Estimation</td><td>0.916</td><td>30.746</td><td>0.771</td><td>49.518</td><td>0.973</td><td>23.237</td></tr><tr><td>ANS</td><td>0.948</td><td>32.701</td><td>0.862</td><td>55.608</td><td>0.983</td><td>23.538</td></tr></table>
+
+![](images/634add30d71a88e4809c1ba46c5269929205bf36e731d5b453c2c37dcd0a2fce.jpg)  
+Figure 4: Exploration visualization. Figure showing a sample trajectory of the Active Neural SLAM model in the Exploration task. Top: RGB observations seen by the agent. Inset: Global ground truth map and pose (not visible to the agent). Bottom: Local map and pose predictions. Long-term goals selected by the Global policy are shown by blue circles. The ground-truth map and pose are under-laid in grey. Map prediction is overlaid in green, with dark green denoting correct predictions and light green denoting false positives. Agent pose predictions are shown in red. The light blue shaded region shows the explored area.
+
+# 6.1 ABLATIONS
+
+Local Policy. An alternative to learning a Local Policy is to have a deterministic policy which follows the plan given by the Planner. As shown in Table 2, the ANS model performs slightly worse without the Local Policy. The Local Policy is designed to adapt to small errors in Mapping. We observed Local policy overcoming false positives encountered in mapping. For example, the Neural SLAM module could sometime wrongly predict a carpet as an obstacle. In this case, the planner would plan to go around the carpet. However, if the short-term goal is beyond the carpet, the Local policy can understand that the carpet is not an obstacle based on the RGB observation and learn to walk over it.
+
+Global Policy. An alternative to learning a Global Policy for sampling long-term goals is to use a classical algorithm called Frontier-based exploration (FBE) (Yamauchi, 1997). A frontier is defined as the boundary between the explored free space and the unexplored space. Frontier-based exploration essentially sample points on this frontier as goals to explore the space. There are different variants of Frontier-based exploration based on the sampling strategy. Holz et al. (2010) compare different sampling strategies and find that sampling the point on the frontier closest to the agent gives the best results empirically. We implement this variant and replace it with our learned Global Policy. As shown in Table 2, the performance of the Frontier-based exploration policy is comparable on small scenes, but around $10 \%$ lower on large scenes, relative to the Global policy. This indicates the importance of learning as compared to classical exploration methods in larger scenes. Qualitatively, we observed that Frontier-based exploration spent a lot of time exploring corners or small areas behind furniture. In contrast, the trained Global policy ignored small spaces and chose distant long-term goals which led to higher coverage.
+
+Pose Estimation. A difference between ANS and the baselines is that ANS uses additional supervision to train the Pose Estimator. In order to understand whether the performance gain is coming from this additional supervision, we remove the Pose Estimator from ANS and just use the input sensor reading as our pose estimate. Results in Table 2 show that the ANS still outperforms the baselines even without the Pose Estimator. We also observed that performance without the pose estimator drops only about $1 \%$ on small scenes, but around $10 \%$ on large scenes. This is expected because larger scenes take longer to explore, and pose errors accumulate over time to cause drift. Passing the ground truth pose as input the baselines instead of the sensor reading did not improve their performance.
+
+![](images/db3db1a4008a3d6ee4a8549012e244e24eeb09c0897fc920d47163d72bdcc9c9.jpg)  
+Figure 5: Real-world Transfer. Left: Image showing the living area in an apartment used for the real-world experiments. Right: Sample images seen by the robot and the predicted map. The long-term goal selected by the Global Policy is shown by a blue circle on the map.
+
+# 6.2 REAL-WORLD TRANSFER
+
+We deploy the trained ANS policy on a Locobot in the real-world. In order to match the real-world observations to the simulator observations as closely as possible, we change the simulator input configuration to match the camera intrinsics on the Locobot. This includes the camera height and horizontal and vertical field-of-views. In Figure 5, we show an episode of ANS exploring the living area in an apartment. The figure shows that the policy transfers well to the real-world and is able to effectively explore the environment. The long-term goals sampled by the Global policy (shown by blue circles on the map) are often towards open spaces in the explored map, which indicates that it is learning to exploit the structure in the map. Please refer to the project webpage for real-world transfer videos.
+
+# 6.3 POINTGOAL TASK TRANSFER.
+
+PointGoal has been the most studied task in recent literature on navigation where the objective is to navigate to a goal location whose relative coordinates are given as input in a limited time budget. In this task, each episode ends when either the agent takes the stop action or at a maximum of 500 timesteps. An episode is considered a success when the final position of the agent is within $0 . 2 \mathrm { m }$ of the goal location. In addition to Success rate (Succ), Success weighted by (normalized inverse) Path Length or SPL is also used as a metric for evaluation as proposed by Anderson et al. (2018).
+
+All the baseline models trained for the task of Exploration either need to be retrained or at least finetuned to be transferred to the Pointgoal task. The modularity of ANS provides it another advantage that it can be transferred to the Pointgoal task without any additional training. For transferring to the Pointgoal task, we just fix the Global policy to always output the PointGoal coordinates as the long-term goal and use the Local Policy and Neural SLAM module trained for the Exploration task. We found that an ANS policy trained on exploration, when transferred to the Pointgoal task performed better than several RL and Imitation Learning baselines trained on the Pointgoal task. The transferred ANS model achieves a success rate/SPL of 0.950/0.846 as compared to 0.827/0.730 for the best baseline model on Gibson val set. The ANS model also generalized significantly better than the baselines to harder goals and to the Matterport domain. In addition to better performance, ANS was also 10 to 75 times more sample efficient than the baselines. This transferred ANS policy was also the winner of the CVPR 2019 Habitat Pointgoal Navigation Challenge for both RGB and RGB-D tracks among over 150 submissions from 16 teams. These results highlight a key advantage of our model. It allows us to transfer the knowledge of obstacle avoidance and control in low-level navigation across tasks, as the Local Policy and Neural SLAM module are task-invariant. More details about the Pointgoal experiments, baselines, results including domain and goal generalization on the Pointgoal task are provided in the supplementary material.
+
+# 7 CONCLUSION
+
+In this paper, we proposed a modular navigational model which leverages the strengths of classical and learning-based navigational methods. We show that the proposed model outperforms prior methods on both Exploration and PointGoal tasks and shows strong generalization across domains, goals, and tasks. In the future, the proposed model can be extended to complex semantic tasks such as Semantic Goal Navigation and Embodied Question Answering by using a semantic Neural SLAM module which creates a multi-channel map capturing semantic properties of the objects in the environment. The model can also be combined with prior work on Localization to relocalize in a previously created map for efficient navigation in subsequent episodes.
+
+# ACKNOWLEDGEMENTS
+
+This work was supported by IARPA DIVA D17PC00340, ONR Grant N000141812861, ONR MURI, ONR Young Investigator, DARPA MCS, and Apple. We would also like to acknowledge NVIDIA’s GPU support. We thank Guillaume Lample for discussions and coding during the initial stages of this project.
+
+# Licenses for referenced datasets.
+
+Gibson: http://svl.stanford.edu/gibson2/assets/GDS_agreement.pdf Matterport3D: http://kaldir.vc.in.tum.de/matterport/MP_TOS.pdf
+
+# REFERENCES
+
+Peter Anderson, Angel Chang, Devendra Singh Chaplot, Alexey Dosovitskiy, Saurabh Gupta, Vladlen Koltun, Jana Kosecka, Jitendra Malik, Roozbeh Mottaghi, Manolis Savva, et al. On evaluation of embodied navigation agents. arXiv preprint arXiv:1807.06757, 2018.
+
+Peter Auer. Using confidence bounds for exploitation-exploration trade-offs. Journal of Machine Learning Research, 3(Nov):397–422, 2002.
+
+Somil Bansal, Varun Tolani, Saurabh Gupta, Jitendra Malik, and Claire Tomlin. Combining optimal control and learning for visual navigation in novel environments. In Conference on Robot Learning (CoRL), 2019.
+
+Andrew G Barto and Sridhar Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete event dynamic systems, 13(1-2):41–77, 2003.
+
+John Canny. The complexity of robot motion planning. MIT press, 1988.
+
+Luca Carlone, Jingjing Du, Miguel Kaouk $\mathrm { N g }$ , Basilio Bona, and Marina Indri. Active slam and exploration with particle filters using kullback-leibler divergence. Journal of Intelligent & Robotic Systems, 75(2):291–311, 2014.
+
+Angel Chang, Angela Dai, Thomas Funkhouser, Maciej Halber, Matthias Niebner, Manolis Savva, Shuran Song, Andy Zeng, and Yinda Zhang. Matterport3d: Learning from rgb-d data in indoor environments. In 2017 International Conference on 3D Vision (3DV), pages 667–676. IEEE, 2017.
+
+Devendra Singh Chaplot and Guillaume Lample. Arnold: An autonomous agent to play fps games. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.
+
+Devendra Singh Chaplot, Guillaume Lample, Kanthashree Mysore Sathyendra, and Ruslan Salakhutdinov. Transfer deep reinforcement learning in 3d environments: An empirical study. In NIPS Deep Reinforcemente Leaning Workshop, 2016.
+
+Devendra Singh Chaplot, Emilio Parisotto, and Ruslan Salakhutdinov. Active neural localization. ICLR, 2018.
+
+Tao Chen, Saurabh Gupta, and Abhinav Gupta. Learning exploration policies for navigation. In ICLR, 2019.
+
+Kyunghyun Cho, Bart Van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder-decoder approaches. Eighth Workshop on Syntax, Semantics and Structure in Statistical Translation, 2014.
+
+Abhishek Das, Samyak Datta, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Embodied question answering. In CVPR, 2018a.
+
+Abhishek Das, Georgia Gkioxari, Stefan Lee, Devi Parikh, and Dhruv Batra. Neural modular control for embodied question answering. In Conference on Robot Learning, pages 53–62, 2018b.
+
+Peter Dayan and Geoffrey E Hinton. Feudal reinforcement learning. In Advances in neural information processing systems, pages 271–278, 1993.
+
+Christian Dornhege and Alexander Kleiner. A frontier-void-based approach for autonomous exploration in 3d. Advanced Robotics, 27(6):459–468, 2013.
+
+Kuan Fang, Alexander Toshev, Li Fei-Fei, and Silvio Savarese. Scene memory transformer for embodied agents in long-horizon tasks. In CVPR, 2019.
+
+J. Fuentes-Pacheco, J. Ruiz-Ascencio, and J. M. Rendón-Mancha. Visual simultaneous localization and mapping: a survey. Artificial Intelligence Review, 2015.
+
+Daniel Gordon, Aniruddha Kembhavi, Mohammad Rastegari, Joseph Redmon, Dieter Fox, and Ali Farhadi. Iqa: Visual question answering in interactive environments. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 4089–4098, 2018.
+
+Saurabh Gupta, James Davidson, Sergey Levine, Rahul Sukthankar, and Jitendra Malik. Cognitive mapping and planning for visual navigation. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 2616–2625, 2017.
+
+Richard Hartley and Andrew Zisserman. Multiple view geometry in computer vision. Cambridge university press, 2003.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 770–778, 2016.
+
+Joao F Henriques and Andrea Vedaldi. Mapnet: An allocentric spatial memory for mapping environments. In proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 8476–8484, 2018.
+
+Dirk Holz, Nicola Basilico, Francesco Amigoni, and Sven Behnke. Evaluating the efficiency of frontier-based exploration strategies. In ISR 2010 (41st International Symposium on Robotics) and ROBOTIK 2010 (6th German Conference on Robotics), pages 1–8. VDE, 2010.
+
+Shahram Izadi, David Kim, Otmar Hilliges, David Molyneaux, Richard Newcombe, Pushmeet Kohli, Jamie Shotton, Steve Hodges, Dustin Freeman, Andrew Davison, and Andrew Fitzgibbon. KinectFusion: real-time 3D reconstruction and interaction using a moving depth camera. UIST, 2011.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in neural information processing systems, pages 2017–2025, 2015.
+
+Thomas Jaksch, Ronald Ortner, and Peter Auer. Near-optimal regret bounds for reinforcement learning. Journal of Machine Learning Research, 11(Apr):1563–1600, 2010.
+
+Elia Kaufmann, Mathias Gehrig, Philipp Foehn, René Ranftl, Alexey Dosovitskiy, Vladlen Koltun, and Davide Scaramuzza. Beauty and the beast: Optimal methods meet learning for drone racing. In 2019 International Conference on Robotics and Automation (ICRA), pages 690–696. IEEE, 2019.
+
+Lydia E Kavraki, Petr Svestka, J-C Latombe, and Mark H Overmars. Probabilistic roadmaps for path planning in high-dimensional configuration spaces. RA, 1996.
+
+Michael Kearns and Satinder Singh. Near-optimal reinforcement learning in polynomial time. Machine learning, 49(2-3):209–232, 2002.
+
+Arbaaz Khan, Clark Zhang, Nikolay Atanasov, Konstantinos Karydis, Daniel D Lee, and Vijay Kumar. End-to-end navigation in unknown environments using neural networks. arXiv preprint arXiv:1707.07385, 2017.
+
+S. Kohlbrecher, J. Meyer, O. von Stryk, and U. Klingauf. A flexible and scalable slam system with full 3d motion estimation. In Proc. IEEE International Symposium on Safety, Security and Rescue Robotics (SSRR). IEEE, November 2011.
+
+Thomas Kollar and Nicholas Roy. Trajectory optimization using reinforcement learning for map exploration. The International Journal of Robotics Research, 27(2):175–196, 2008.
+
+Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https://github. com/ikostrikov/pytorch-a2c-ppo-acktr-gail, 2018.
+
+Guillaume Lample and Devendra Singh Chaplot. Playing FPS games with deep reinforcement learning. In Thirty-First AAAI Conference on Artificial Intelligence, 2017.
+
+Steven M Lavalle and James J Kuffner Jr. Rapidly-exploring random trees: Progress and prospects. In Algorithmic and Computational Robotics: New Directions, 2000.
+
+Lisa Lee, Emilio Parisotto, Devendra Singh Chaplot, Eric Xing, and Ruslan Salakhutdinov. Gated path planning networks. In ICML, 2018.
+
+Ruben Martinez-Cantin, Nando de Freitas, Eric Brochu, José Castellanos, and Arnaud Doucet. A bayesian exploration-exploitation approach for optimal online sensing and planning with a visually guided mobile robot. Autonomous Robots, 27(2):93–103, 2009.
+
+Piotr Mirowski, Razvan Pascanu, Fabio Viola, Hubert Soyer, Andrew J Ballard, Andrea Banino, Misha Denil, Ross Goroshin, Laurent Sifre, Koray Kavukcuoglu, et al. Learning to navigate in complex environments. ICLR, 2017.
+
+Raul Mur-Artal and Juan D Tardós. Orb-slam2: An open-source slam system for monocular, stereo, and rgb-d cameras. IEEE Transactions on Robotics, 33(5):1255–1262, 2017.
+
+Adithyavairavan Murali, Tao Chen, Kalyan Vasudev Alwala, Dhiraj Gandhi, Lerrel Pinto, Saurabh Gupta, and Abhinav Gupta. Pyrobot: An open-source robotics framework for research and benchmarking. arXiv preprint arXiv:1906.08236, 2019.
+
+Richard A Newcombe, Steven J Lovegrove, and Andrew J Davison. Dtam: Dense tracking and mapping in real-time. In 2011 international conference on computer vision, pages 2320–2327. IEEE, 2011.
+
+Emilio Parisotto and Ruslan Salakhutdinov. Neural map: Structured memory for deep reinforcement learning. ICLR, 2018.
+
+Adam Paszke, Sam Gross, Soumith Chintala, Gregory Chanan, Edward Yang, Zachary DeVito, Zeming Lin, Alban Desmaison, Luca Antiga, and Adam Lerer. Automatic differentiation in pytorch. NIPS 2017 Autodiff Workshop, 2017.
+
+Andrzej Pronobis and Patric Jensfelt. Large-scale semantic mapping and reasoning with heterogeneous modalities. In 2012 IEEE International Conference on Robotics and Automation, pages 3515–3522. IEEE, 2012.
+
+Morgan Quigley, Brian Gerkey, Ken Conley, Josh Faust, Tully Foote, Jeremy Leibs, Eric Berger, Rob Wheeler, and Andrew Ng. Ros: an open-source robot operating system. In Proc. of the IEEE Intl. Conf. on Robotics and Automation (ICRA) Workshop on Open Source Robotics, Kobe, Japan, May 2009.
+
+Nikolay Savinov, Alexey Dosovitskiy, and Vladlen Koltun. Semi-parametric topological memory for navigation. In International Conference on Learning Representations (ICLR), 2018.
+
+Nikolay Savinov, Anton Raichuk, Raphaël Marinier, Damien Vincent, Marc Pollefeys, Timothy Lillicrap, and Sylvain Gelly. Episodic curiosity through reachability. In ICLR, 2019.
+
+Manolis Savva, Abhishek Kadian, Oleksandr Maksymets, Yili Zhao, Erik Wijmans, Bhavana Jain, Julian Straub, Jia Liu, Vladlen Koltun, Jitendra Malik, et al. Habitat: A platform for embodied ai research. In Proceedings of the IEEE International Conference on Computer Vision, pages 9339–9347, 2019.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv preprint arXiv:1707.06347, 2017.
+
+James A Sethian. A fast marching level set method for monotonically advancing fronts. Proceedings of the National Academy of Sciences, 93(4):1591–1595, 1996.
+
+Shuran Song, Fisher Yu, Andy Zeng, Angel X Chang, Manolis Savva, and Thomas Funkhouser. Semantic scene completion from a single depth image. In CVPR, 2017.
+
+Cyrill Stachniss, Giorgio Grisetti, and Wolfram Burgard. Information gain-based exploration using rao-blackwellized particle filters. In Robotics: Science and Systems, volume 2, pages 65–72, 2005.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Richard S Sutton, Doina Precup, and Satinder Singh. Between mdps and semi-mdps: A framework for temporal abstraction in reinforcement learning. Artificial intelligence, 112(1-2):181–211, 1999.
+
+Aviv Tamar, Yi Wu, Garrett Thomas, Sergey Levine, and Pieter Abbeel. Value iteration networks. In Advances in Neural Information Processing Systems, pages 2154–2162, 2016.
+
+Sebastian Thrun, Wolfram Burgard, and Dieter Fox. Probabilistic robotics. MIT press, 2005.
+
+Matthew R Walter, Sachithra Hemachandra, Bianca Homberg, Stefanie Tellex, and Seth Teller. Learning semantic maps from natural language descriptions. In Robotics: Science and Systems, 2013.
+
+Fei Xia, Amir R. Zamir, Zhi-Yang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson Env: real-world perception for embodied agents. In Computer Vision and Pattern Recognition (CVPR), 2018 IEEE Conference on. IEEE, 2018.
+
+Kai Xu, Lintao Zheng, Zihao Yan, Guohang Yan, Eugene Zhang, Matthias Niessner, Oliver Deussen, Daniel Cohen-Or, and Hui Huang. Autonomous reconstruction of unknown indoor scenes guided by time-varying tensor fields. ACM Transactions on Graphics (TOG), 36(6):202, 2017.
+
+Brian Yamauchi. A frontier-based approach for autonomous exploration. In cira, volume 97, page 146, 1997.
+
+Jingwei Zhang, Lei Tai, Joschka Boedecker, Wolfram Burgard, and Ming Liu. Neural slam: Learning to explore with external memory. arXiv preprint arXiv:1706.09520, 2017.
+
+Yuke Zhu, Roozbeh Mottaghi, Eric Kolve, Joseph J Lim, Abhinav Gupta, Li Fei-Fei, and Ali Farhadi. Target-driven visual navigation in indoor scenes using deep reinforcement learning. In Robotics and Automation (ICRA), 2017 IEEE International Conference on, pages 3357–3364. IEEE, 2017.
+
+Table 3: Performance of the proposed model, Active Neural SLAM (ANS) and all the baselines on the Exploration task. ‘ANS - Task Transfer’ refers to the ANS model transferred to the PointGoal task after training on the Exploration task.   
+
+<table><tr><td colspan="4"></td><td colspan="2">Domain Generalization</td><td colspan="3">Goal Generalization</td></tr><tr><td></td><td>Test Setting →</td><td>Gibson Val</td><td></td><td>MP3D Test</td><td></td><td>Hard-GEDR</td><td></td><td>Hard-Dist</td></tr><tr><td>Train Task</td><td>Method</td><td>Succ</td><td>SPL</td><td>Succ</td><td>SPL</td><td>Succ SPL</td><td>Succ</td><td> SPL</td></tr><tr><td>PointGoal</td><td>Random</td><td>0.027</td><td>0.021</td><td>0.010</td><td>0.010</td><td>0.000 0.000</td><td>0.000</td><td>0.000</td></tr><tr><td></td><td>RL + Blind</td><td>0.625</td><td>0.421</td><td>0.136</td><td>0.087</td><td>0.052 0.020</td><td>0.008</td><td>0.006</td></tr><tr><td></td><td>RL + 3LConv +GRU</td><td>0.550</td><td>0.406</td><td>0.102</td><td>0.080</td><td>0.072 0.046</td><td>0.006</td><td>0.006</td></tr><tr><td></td><td>RL +Res18+GRU</td><td>0.561</td><td>0.422</td><td>0.160</td><td>0.125</td><td>0.176 0.109</td><td>0.004</td><td>0.003</td></tr><tr><td></td><td>RL +Res18 +GRU+AuxDepth</td><td>0.640</td><td>0.461</td><td>0.189</td><td>0.143</td><td>0.277 0.197</td><td>0.013</td><td>0.011</td></tr><tr><td></td><td>RL+Res18 +GRU+ ProjDepth</td><td>0.614</td><td>0.436</td><td>0.134</td><td>0.111</td><td>0.180 0.129</td><td>0.008</td><td>0.004</td></tr><tr><td></td><td>IL + Res18+GRU</td><td>0.823</td><td>0.725</td><td>0.365</td><td>0.318</td><td>0.682 0.558</td><td>0.359</td><td>0.310</td></tr><tr><td></td><td>CMP</td><td>0.827</td><td>0.730</td><td>0.320</td><td>0.270</td><td>0.670 0.553</td><td>0.369</td><td>0.318</td></tr><tr><td></td><td>ANS</td><td>0.951</td><td>0.848</td><td>0.593</td><td>0.496</td><td>0.824 0.710</td><td>0.662</td><td>0.534</td></tr><tr><td>Exploration</td><td>ANS - Task Transfer</td><td>0.950</td><td>0.846</td><td>0.588</td><td>0.490</td><td>0.821 0.703</td><td>0.665</td><td>0.532</td></tr></table>
+
+# A POINTGOAL EXPERIMENTS
+
+PointGoal has been the most studied task in recent literature on navigation where the objective is to navigate to a goal location whose relative coordinates are given as input in a limited time budget. We follow the PointGoal task setup from Savva et al. (2019), using train/val/test splits for both Gibson and Matterport datasets. Note that the set of scenes used in each split is disjoint, which means the agent is tested on new scenes never seen during training. Gibson test set is not public but rather held out on an online evaluation server3. We report the performance of our model on the Gibson test set when submitted to the online server but also use the validation set as another test set for extensive comparison and analysis. We do not use the validation set for hyper-parameter tuning.
+
+Savva et al. (2019) identify two measures to quantify the difficulty of a PointGoal dataset. The first is the average geodesic distance (distance along the shortest path) to the goal location from the starting location of the agent, and the second is the average geodesic to Euclidean distance ratio (GED ratio). The GED ratio is always greater than or equal to 1, with higher ratios resulting in harder episodes. The train/val/test splits in the Gibson dataset come from the same distribution of having similar average geodesic distance and GED ratio. In order to analyze the performance of the proposed model on out-of-set goal distribution, we create two harder sets, Hard-Dist and Hard-GEDR. In the Hard-Dist set, the geodesic distance to goal is always more than $1 0 \mathrm { m }$ and the average geodesic distance to the goal is $1 3 . 4 8 \mathrm { m }$ as compared to $6 . 9 / 6 . 5 / 7 . 0 \mathrm { m }$ in train/val/test splits (Savva et al., 2019). Hard-GEDR set consists of episodes with an average GED ratio of 2.52 and a minimum GED ratio of 2.0 as compared to average GED ratio 1.37 in the Gibson val set.
+
+We also follow the episode specification from Savva et al. (2019). Each episode ends when either the agent takes the stop action or at a maximum of 500 timesteps. An episode is considered a success when the final position of the agent is within $0 . 2 \mathrm { m }$ of the goal location. In addition to Success rate (Succ), we also use Success weighted by (normalized inverse) Path Length or SPL as a metric for evaluation for the PointGoal task as proposed by Anderson et al. (2018).
+
+# A.1 POINTGOAL RESULTS
+
+In Table 3, we show the performance of the proposed model transferred to the PointGoal task along with the baselines trained on the PointGoal task with the same amount of data (10million frames). The proposed model achieves a success rate/SPL of 0.950/0.846 as compared to 0.827/0.730 for the best baseline model on Gibson val set. We also report the performance of the proposed model trained from scratch on the PointGoal task for 10 million frames. The results indicate that the performance of ANS transferred from Exploration is comparable to ANS trained on PointGoal. This highlights a key advantage of our model. It allows us to transfer the knowledge of obstacle avoidance and control in low-level navigation across tasks, as the Local Policy and Neural SLAM module are task-invariant.
+
+Sample efficiency. RL models are typically trained for more than 10 million samples. In order to compare the performance and sample-efficiency, we trained the best performing RL model $[ \mathrm { R L } +$ $\mathrm { R e s 1 8 + G R U + P r o j D e p t h }$ ) for 75 million frames and it achieved a Succ/SPL of 0.678/0.486. ANS reaches the performance of 0.789/0.703 SPL/Succ at only 1 million frames. These numbers indicate that ANS achieves $> 7 5 \times$ speedup as compared to the best RL baseline.
+
+![](images/125f539165ecf987c00d0745b3114a291552b619d4ec5fd407abd5a90e170248.jpg)  
+Figure 7: Performance of the proposed ANS model along with CMP and $\mathrm { I L } + \mathrm { R e s 1 8 + G I }$ RU (GRU) baselines with increase in geodesic distance to goal and increase in GED Ratio on the Gibson Val set.
+
+![](images/448b2d88ce33e99167f69134866448cb347cdd5ee381be5723879a436e05a91f.jpg)  
+Figure 8: Figure showing sample trajectories of the proposed model along with the predicted map in the PointGoal task. The starting and goal locations are shown by black squares and blue circles, respectively. The ground-truth map is under-laid in grey. Map prediction is overlaid in green, with dark green denoting correct predictions and light green denoting false positives. The blue shaded region shows the explored area prediction. On the left, we show some successful trajectories which indicate that the model is effective at long distance goals with high GED ratio. On the right, we show a failure case due to mapping error.
+
+Domain and Goal Generalization: In Table 3 (see shaded region), we evaluate all the baselines and ANS trained on the PointGoal task in the Gibson domain on the test set in Matterport domain as well as the harder goal sets in Gibson. We also transfer ANS trained on Exploration in Gibson on all the 3 sets. The results show that ANS outperforms all the baselines at all generalization sets. Interestingly, RL based methods almost fail completely on the Hard-Dist set. We also analyze the performance of the proposed model as compared to the two best baselines CMP and $\mathrm { I L } + \mathrm { R e s } 1 8 + \mathrm { G R U }$ as a function of geodesic distance to goal and GED ratio in Figure 7. The performance of the baselines drops faster as compared to ANS, especially with the increase in goal distance. This indicates that end-to-end learning methods are effective at short-term navigation but struggle when long-term planning is required to reach a distant goal. In Figure 8, we show some example trajectories of the ANS model along with the predicted map. The successful trajectories indicate that the model exhibits strong backtracking behavior which makes it effective at distant goals requiring long-term planning. Figure 9 visualizes a trajectory in the PointGoal task show first-person observation and corresponding map predictions. Please refer to the project webpage for visualization videos.
+
+![](images/3ee6da52fec18deff15dd2613acba5ba9c0a15c36cfd5e21d96779f911eb4415.jpg)  
+Figure 6: Screenshot of CVPR 2019 Habitat Challenge Results. The proposed model was submitted under code-name ‘Arnold’.
+
+Habitat Challenge Results. We submitted the ANS model to the CVPR 2019 Habitat Pointgoal Navigation Challenge. The results are shown in Figure 6. ANS was submitted under code-name ‘Arnold’. ANS was the winning entry for both RGB and RGB-D tracks among over 150 submissions from 16 teams, achieving an SPL of 0.805 (RGB) and 0.948 (RGB-D) on the Test Challenge set.
+
+# B NOISE MODEL IMPLEMENTATION DETAILS
+
+In order to implement the actuation and sensor noise models, we would like to collect data for navigational actions in the Habitat simulator. We use three default navigational actions: Forward:
+
+![](images/284a0ddd76aff9d45adebc1c0417924b802d37437fdd8a990f36ba8c9cb9d790.jpg)  
+Figure 9: Pointgoal visualization. Figure showing sample trajectories of the proposed model along with predicted map in the Pointgoal task as the episode progresses. The starting and goal locations are shown by black squares and blue circles, respectively. Ground truth map is under-laid in grey. Map prediction is overlaid in green, with dark green denoting correct predictions and light green denoting false positives. Blue shaded region shows the explored area prediction.
+
+move forward by $2 5 \mathrm { c m }$ , Turn Right: on the spot rotation clockwise by 10 degrees, and Turn Left: on the spot rotation counter-clockwise by 10 degrees. The control commands are implemented as $u _ { F o r w a r d } = ( 0 . 2 5 , 0 , 0 )$ , $u _ { R i g h t } : ( 0 , 0 , - 1 0 * \pi / 1 8 0 )$ and $u _ { L e f t } : ( 0 , 0 , 1 0 * \pi / 1 8 0 )$ . In practice, a robot can also rotate slightly while moving forward and translate a bit while rotating on-the-spot, creating rotational actuation noise in forward action and similarly, a translation actuation noise in on-the-spot rotation actions.
+
+We use a Locobot 4 to collect data for building the actuation and sensor noise models. We use the pyrobot API (Murali et al., 2019) along with ROS (Quigley et al., 2009) to implement the control commands and get sensor readings. In order to get an accurate agent pose, we use an Hokuyo UST-10LX Scanning Laser Rangefinder (LiDAR) which is especially very precise in our scenario as we take static readings in 2D (Kohlbrecher et al., 2011). We install the LiDAR on the Locobot by replacing the arm with the LiDAR. We note that the Hokuyo UST-10LX Scanning Laser Rangefinder is an expensive sensor. It costs $\$ 1600$ as compared to the whole Locobot costing less than $\$ 2000$ without the arm. Using expensive sensors can improve the performance of a model, however, for a method to be scalable, it should ideally work with cheaper sensors too. In order to demonstrate the scalability of our method, we use the LiDAR only to collect the data for building noise models and not for training or deploying navigation policies in the real-world.
+
+For the sensor estimate, we use the Kobuki base odometry available in Locobot. We approximate the LiDAR pose estimate to be the true pose of the agent as it is orders of magnitude more accurate than the base sensor. For each action, we collect 600 datapoints from both the base sensor and the LiDAR, making a total of 3600 datapoints $( 6 0 0 * 3 * 2 )$ ). We use 500 datapoints for each action to fit the actuation and sensor noise models and use the remaining 100 datapoints for validation. For each action $a$ , the LiDAR pose estimates gives us samples of $p _ { 1 }$ and the base sensor readings give us samples of $p _ { 1 } ^ { \prime } , i = 1 , 2 , \ldots , 6 0 0$ . The difference between LiDAR estimates $( p _ { 1 } ^ { i } )$ and control command $( \Delta u _ { a } )$ gives us samples for the actuation noise for the action $a$ : $\epsilon _ { a c t , a } ^ { i } = \bar { p _ { 1 } ^ { i } } - \Delta u _ { a }$ and difference between base sensor readings and LiDAR estimates gives us the samples for the sensor noise, $\epsilon _ { s e n , a } ^ { i } = p _ { 1 } ^ { i ^ { \prime } } - p _ { 1 } ^ { i }$ .
+
+For each action $a$ , we fit a separate Gaussian Mixture Model for the actuation noise and sensor noise using samples $\epsilon _ { a c t , a } ^ { i }$ and $\epsilon _ { s e n , a } ^ { i }$ respectively, making a total of 6 models. We fit Gaussian mixture models with the number of components ranging from 1 to 20 for and pick the model with the highest likelihood on the validation set. Each component in these Gaussian mixture models is a multi-variate Gaussian in 3 variables, $x , y$ and $o$ . We implement these actuation and sensor noise models in the Habitat simulator for our experiments.
+
+# C NEURAL SLAM MODULE IMPLEMENTATION DETAILS
+
+The Neural SLAM module $( f _ { S L A M } )$ takes in the current RGB observation, $s _ { t } \in \mathbb { R } ^ { 3 \times H \times W }$ , the current and last sensor reading of the agent pose $x _ { t - 1 : t } ^ { \prime }$ and the map at the previous time step $m _ { t - 1 } \ \in \ \mathbb { R } ^ { 2 \times M \times M }$ and outputs an updated map, $m _ { t } ~ \in ~ \mathbb { R } ^ { 2 \times M \times M }$ , and the current agent pose estimate, $\hat { x } _ { t }$ (see Figure 2):
+
+$$
+m _ { t } , \hat { x } _ { t } = f _ { S L A M } ( s _ { t } , x _ { t - 1 : t } ^ { \prime } , \hat { x } _ { t - 1 } , m _ { t - 1 } | \theta _ { S } , b _ { t - 1 } )
+$$
+
+where $\theta _ { S }$ denote the trainable parameters and $b _ { t - 1 }$ denotes internal representations of the Neural SLAM module. The Neural SLAM module can be broken down into two parts, a Mapper $( f _ { M a p } )$ and a Pose Estimator Unit $( f _ { P E } , )$ . The Mapper outputs a egocentric top-down 2D spatial map, $p _ { t } ^ { e g o } \in [ 0 , 1 ] ^ { 2 \times V \times V }$ (where $V$ is the vision range), predicting the obstacles and the explored area in the current observation: $p _ { t } ^ { e g o } = f _ { M a p } ( s _ { t } | \bar { \theta _ { M } } )$ , where $\theta _ { M }$ are the parameters of the Mapper. It consists of Resnet18 convolutional layers to produce an embedding of the observation. This embedding is passed through two fully-connected layers followed by 3 deconvolutional layers to get the first-person top-down 2D spatial map prediction.
+
+Now, we would like to add the egocentric map prediction $( p _ { t } ^ { e g o } )$ to the geocentric map from the previous time step $( m _ { t - 1 } )$ . In order to transform the egocentric map to the geocentric frame, we need the pose of the agent in the geocentric frame. The sensor reading $ { \boldsymbol { { x } } } _ { t } ^ { \prime }$ is typically noisy. Thus, we have a Pose Estimator to correct the sensor reading and give an estimate of the agent’s geocentric pose.
+
+In order to estimate the pose of the agent, we first calculate the relative pose change $( d x )$ from the last time step using the sensor readings at the current and last time step $( x _ { t - 1 } ^ { \prime } , x _ { t } ^ { \prime } )$ . Then we use a Spatial Transformation (Jaderberg et al., 2015) on the egocentric map prediction at the last frame $( \bar { p } _ { t - 1 } ^ { e g o } )$ based on the relative pose change $( d x )$ , $p _ { t - 1 } ^ { \prime } = \bar { f _ { S T } } ( p _ { t - 1 } ^ { e g o } | d x )$ . Note that the parameters of this Spatial Transformation are not learnt, but calculated using the pose change $( d x )$ . This transforms the projection at the last step to the current egocentric frame of reference. If the sensor was accurate, $p _ { t - 1 } ^ { \prime }$ would highly overlap with $p _ { t } ^ { e g o }$ . The Pose Estimator Unit takes in $p _ { t - 1 } ^ { \prime }$ and $p _ { t } ^ { e g o }$ as input and predicts the relative pose change: $\hat { d x } _ { t } = f _ { P E } ( p _ { t - 1 } ^ { \prime } , p _ { t } ^ { e g o } | \theta _ { P } )$ The intuition is that by looking at the egocentric predictions of the last two frames, the pose estimator can learn to predict the small translation and/or rotation that would align them better. The predicted relative pose change is then added to the last pose estimate to get the final pose estimate $\bar { \hat { x _ { t } } } = \hat { x } _ { t - 1 } + \hat { d x _ { t } }$ .
+
+Finally, the egocentric spatial map prediction is transformed to the geocentric frame using the current pose prediction of the agent $( \hat { x } _ { t } )$ using another Spatial Transformation and aggregated with the previous spatial map $( m _ { t - 1 } )$ using Channel-wise Pooling operation: $m _ { t } = m _ { t - 1 } + { \bar { f } } _ { S T } ( p _ { t } ^ { e g o } | { \hat { x _ { t } } } )$ .
+
+Combing all the functions and transformations:
+
+$$
+\begin{array} { r l } & { m _ { t } , \hat { x } _ { t } = f _ { S L A M } \big ( s _ { t } , x _ { t - 1 : t } ^ { \prime } , m _ { t - 1 } \vert \theta _ { S } , b _ { t - 1 } \big ) } \\ & { \quad p _ { t } ^ { e g o } = f _ { M a p } \big ( s _ { t } \vert \theta _ { M } \big ) } \\ & { \quad \quad \hat { x } _ { t } = \hat { x } _ { t - 1 } + f _ { P E } \big ( f _ { S T } \big ( p _ { t - 1 } ^ { e g o } \vert \hat { x } _ { t - 1 : t } \big ) , p _ { t } ^ { e g o } \vert \theta _ { P } \big ) } \\ & { \quad m _ { t } = m _ { t - 1 } + f _ { S T } \big ( p _ { t } ^ { e g o } \vert \hat { x } _ { t } \big ) } \\ & { \quad \quad \quad \quad \mathrm { w h e r e ~ } \theta _ { M } , \theta _ { P } \in \theta _ { S } , \quad \mathrm { a n d } \quad p _ { t - 1 } ^ { e g o } , \hat { x } _ { t - 1 } \in b _ { t - 1 } } \end{array}
+$$
+
+# D ARCHITECTURE DETAILS
+
+We use PyTorch (Paszke et al., 2017) for implementing and training our model. The Mapper in the Neural SLAM module consists of ResNet18 convolutional layers followed by 2 fully-connected layers trained with a dropout of 0.5, followed by 3 deconvolutional layers. The Pose Estimator consists of 3 convolutional layers followed by 3 fully connected layers. The Global Policy is a 5 layer convolutional network followed by 3 fully connected layers. We also pass the agent orientation as a separate input (not captured in the map tensor) to the Global Policy. It is processed by an Embedding layer and added as an input to the fully-connected layers. The Local Policy consists of a pretrained ResNet18 convolutional layers followed by fully connected layers and a recurrent GRU layer. In addition to the RGB observation, the Local policy receives relative distance and angle to the short-term goal as input. We bin the relative distance (bin size increasing with distance), relative angle (5 degree bins) and current timestep (30 time step bins) before passing them through embedding layers. This kind of discretization is used previously for RL policies (Lample and Chaplot, 2017; Chaplot and Lample, 2017) and it improved the sample efficiency as compared to passing the continuous values as input directly. For a fair comparison, we use the same discretization for all the baselines as well. The short-term goal is processed using Embedding layers. For the exact architectures of all the modules, please refer to the open-source code.
+
+# E HYPERPARAMETER DETAILS
+
+We train all the components with 72 parallel threads, with each thread using one of the 72 scenes in the Gibson training set. We maintain a FIFO memory of size 500000 for training the Neural SLAM module. After one step in all the environments (i.e. every 72 steps) we perform 10 updates to the Neural SLAM module with a batch size of 72. We use Adam optimizer with a learning rate of 0.0001. We use binary cross-entropy loss for obstacle map and explored area prediction and MSE Loss for pose prediction (in meters and radians). The obstacle map and explored area loss coefficients are 1 and the pose loss coefficient is 10000 (as MSE loss in meters and radians is much smaller).
+
+The Global policy samples a new goal every 25 timesteps. We use Proximal Policy Optimization (PPO) (Schulman et al., 2017) for training the Global policy. Our PPO implementation for the Global Policy is based on Kostrikov (2018). The reward for the Global policy is the increase in coverage in $m ^ { 2 }$ scaled by 0.02. It is trained with 72 parallel threads and a horizon length of 40 steps (40 steps for Global policy is equivalent to 1000 low-level timesteps as Global policy samples a new goal after every 25 timesteps). We use 36 mini-batches and do 4 epochs in each PPO update. We use Adam optimizer with a learning rate of 0.000025, a discount factor of $\gamma = 0 . 9 9$ , an entropy coefficient of 0.001, value loss coefficient of 0.5 for training the Global Policy.
+
+The Local Policy is trained using binary cross-entropy loss. We use Adam optimizer with a learning rate of 0.0001 for training the Local Policy.
+
+Input frame size is $1 2 8 \times 1 2 8$ , the vision range for the SLAM module is $V = 6 4$ , i.e. $3 . 2 m$ (each cell is $5 c m$ in length). Since there are no parameters dependent on the map size, it can be adaptive. We train with a map size of $M = 4 8 0$ (equivalent to $2 4 m \ r$ ) for training and $M = 9 6 0$ (equivalent to $4 8 m \mathrm { , }$ ) for evaluation. A map of size $4 8 m \times 4 8 m$ is large enough for all scenes in the Gibson val set. The size of the Global Policy input is constant, $G = 2 4 0$ , which means we downscale map by 2 times during training and 4 times during evaluation. All hyperparameters are available in the code.
+
+# F ADDITIONAL RESULTS
+
+![](images/40c6b21156c130b7ecc8258710b6b4b78e01ef968459be3306ccd2323ffc3680.jpg)  
+Figure 10: Plot showing the absolute Coverage in $m ^ { 2 }$ as the episode progresses for ANS and the baselines on the large and small scenes in the Gibson Val set as well as the overall Gibson Val set.

parse/train/Ic9vRN3VpZ/Ic9vRN3VpZ.md

@@ -0,0 +1,237 @@
+# Neo-GNNs: Neighborhood Overlap-aware Graph Neural Networks for Link Prediction
+
+Seongjun Yun, Seoyoon Kim, Junhyun Lee, Jaewoo Kang∗ , Hyunwoo J. Kim∗
+
+Department of Computer Science and Engineering Korea University {ysj5419, sykim45, ljhyun33, kangj, hyunwoojkim}@korea.ac.kr
+
+# Abstract
+
+Graph Neural Networks (GNNs) have been widely applied to various fields for learning over graph-structured data. They have shown significant improvements over traditional heuristic methods in various tasks such as node classification and graph classification. However, since GNNs heavily rely on smoothed node features rather than graph structure, they often show poor performance than simple heuristic methods in link prediction where the structural information, e.g., overlapped neighborhoods, degrees, and shortest paths, is crucial. To address this limitation, we propose Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs) that learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction. Our Neo-GNNs generalize neighborhood overlap-based heuristic methods and handle overlapped multi-hop neighborhoods. Our extensive experiments on Open Graph Benchmark datasets (OGB) demonstrate that Neo-GNNs consistently achieve state-of-the-art performance in link prediction.
+
+# 1 Introduction
+
+Graph-structured data is ubiquitous in a wide range of domains ranging from social network analysis [1, 2, 3] to biology [4, 5, 6, 7] and computer vision [8, 9, 10]. In recent years, numerous variants of Graph neural networks (GNNs) have been proposed for learning representations over graph-structured data. GNNs learn low dimensional representations of nodes or graphs via iterative aggregation of features from neighbors using non-linear transformations. In this manner, GNNs have shown significant improvements over traditional methods, e.g., heuristic methods and embedding-based methods, and achieved state-of-the-art performance on various tasks, such as node classification [11, 12, 13, 14, 15], graph classification [16, 17, 18, 19, 20], and graph generation [21, 22, 23, 24].
+
+However, in link prediction, traditional heuristic methods still show competitive performance compared to GNNs, which often even outperform GNNs. This is because structural information, (e.g., overlapped neighborhoods, degrees, and shortest path), is crucial for link prediction whereas GNNs heavily rely on smoothed node features rather than graph structure. Recently, SEAL [25] has been proposed to consider structural information for link prediction by utilizing the relative distance between the target node pair and their neighborhoods. Nonetheless, SEAL requires the expensive computational cost to apply a GNN independently to an extracted subgraph for each target node pair.
+
+To address this limitation, we propose Neighborhood Overlap-aware Graph Neural Networks (NeoGNNs) that are designed to consider key structural information regarding links without manual processes. Specifically, instead of using input node features, Neo-GNNs first learn to generate useful structrual features for each node from an adjacency matrix. Then Neo-GNNs measure the existence of links by considering the structural features of overlapped neighbhorhoods via neighbhorhood overlap-aware aggregation scheme. Finally, to consider both structural information and input node features, our proposed model adaptively combines scores from Neo-GNNs and feature-based GNNs in an end-to-end fashion. We show that Neo-GNNs consistently outperform both state-of-the-art GNNs and heuristic methods on four Open Graph Benchmark datasets (OGB) for link prediction. Furthermore, Our Neo-GNNs generalize the neighborhood overlap-based heuristic methods which measure the likelihood of the link based on manually designed structural information of overlapped neighbors.
+
+Our contributions are as follows: (i) We propose Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs) that learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction. (ii) Neo-GNNs generalize neighborhood overlap-based heuristic methods and handle overlapped multi-hop neighborhoods. (iii) Our extensive experiments on Open Graph Benchmark datasets (OGB) demonstrate that Neo-GNNs consistently achieve state-of-the-art performance in link prediction.
+
+# 2 Related Works
+
+Graph Neural Networks. GNNs have been designed to learn node representations by using neural networks on graph topology. Among deep learning based approaches, the message passing scheme is dominantly used in recent studies such as GCN [11], GraphSAGE [26], and GAT [12]. Due to the iterative aggregation step, each node representation vector can have information of neighbor nodes in multi-hop relationships required for downstream tasks. However, there is a limitation of the expressive power that is upper-bounded by the 1-Weisfeiler-Lehman (1-WL) graph isomorphism test. To overcome this limitation, recent works have tried to boost the expressive power of GNNs by augmenting node features with ordering vectors or position-aware vectors [11, 27, 28]. The main purpose of these works is to complement GNNs with structural information which is crucial for prediction tasks. Our study focuses on adaptively incorporating structural information to GNNs for the link prediction task.
+
+Link Prediction. Link prediction has been studied in various ways. Conventionally, diverse heuristic methods have been proposed for link prediction. They basically measure the scores of given node pairs based on structural information e.g., overlapped neighbors and shortest path, about the pair of nodes. Common neighbors and preferential attachment [29] exploit structural information about one-hop neighbors to compute the score. To consider more than one-hop relationships, second-order heuristic methods (e.g., Adamic-Adar [30] and resource allocation [31]) and higher-order heuristic methods (e.g., Katz [32] , PageRank [33] , and SimRank [34]) have been proposed. Heuristic methods are extremely effective for link prediction. However, they require manually designed structural information for each heuristic method. To overcome this limitation, embedding-based methods have been proposed. They learn node embeddings based on connections between nodes and compute similarity scores using the embeddings. Typically, Matrix factorization [35] learns node embeddings by decomposing an adjacency matrix of the graph. Random walk-based embedding methods such as Deepwalk [36], and node2vec [37] learn node embeddings by applying the Skip-Gram [38] techniques on the random walks. LINK [39] learns to classify the existence of links based on each row in the adjacency matrix, which includes connectivity information. Since the performance of the embedding methods depends on the sparsity of the input graph, it is hard to regard these methods as generalized ones. Recently, with the success of GNNs in learning graph representations, there have been several attempts to apply them to the link prediction task. Typically, GAE and VGAE [40] learn node representations through GCN to reconstruct the input graph in the auto-encoder framework. Based on the GAE, various GNN architectures have been applied to link prediction. On the other hand, SEAL [25] reformulated the link prediction task to the classification of enclosing subgraphs. Instead of directly predicting the link, enclosing graphs are sampled around each target link to compose dataset and SEAL performs the graph classification task. Due to the node labeling step to mark nodes’ different roles in an enclosing subgraph, SEAL has better performance than GAE even though both are GNN-based methods. However, constructing subgraphs is inefficient because it requires a large amount of computation, whereas our model is as efficient as GAE and can consider structural information like SEAL.
+
+# 3 Methods
+
+The goal of our framework, Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs), is to learn useful structural features from an adjacency matrix and estimate overlapped neighbors for link prediction. We begin with defining the basic notions of graph neural networks for link prediction and review neighborhood overlap-based heuristic methods, and then introduce Neo-GNNs.
+
+# 3.1 Preliminaries
+
+Notations. Consider an undirected graph $\mathcal { G } = ( \nu , \mathcal { E } )$ with $N$ nodes, where $\mathcal { V } = \{ v _ { 1 } , v _ { 2 } , \ldots , v _ { N } \}$ represents a set of nodes and $\mathcal { E } = \{ e _ { i j } \ | \ v _ { i } , v _ { j } \ \in \mathcal { V } \}$ represents a set of edges where the nodes $v _ { i } , v _ { j } \in \mathcal { V }$ are connected. The adjacency matrix $A \in \mathbf { R } ^ { N \times N }$ is defined by $A _ { i j } = 1$ if $e _ { i j } \in \mathcal { E }$ and 0 otherwise. The degree matrix $D \in { \bf R } ^ { N \times N }$ is a diagonal matrix defined by $\begin{array} { r } { D _ { i i } = \sum _ { j } A _ { i j } } \end{array}$ . The nodes of $\mathcal { G }$ have their own feature vectors $\boldsymbol { x } _ { i } \in \mathbf { R } ^ { F }$ $( i \in \{ 1 , 2 , \ldots , N \} )$ , with $X \in \mathbf { R } ^ { N \times F }$ denoting the collection of such vectors in a matrix form.
+
+Graph Neural Networks for Link Prediction. Given a graph $\mathcal { G }$ and a feature matrix $X$ , graph neural networks learn meaningful node representations by an iterative aggregation of transformed representations of neighbor nodes in each $l$ -th GNN layer as follows:
+
+$$
+\begin{array} { r } { H ^ { ( l + 1 ) } = \sigma \left( \tilde { A } _ { \mathrm { G N N } } H ^ { ( l ) } W ^ { ( l ) } \right) , } \end{array}
+$$
+
+where $\tilde { A } _ { \mathbf { G N N } } \in \mathbf { R } ^ { N \times N }$ is the adjacency matrix normalized in different ways depending on each GNN architecture (e.g., D˜ − 12 (A + I )D˜ − 12 ), W (l) ∈ Rd(l)×d(l+1) i s a trainable weight matrix, and $H ^ { ( 0 ) }$ is the node feature matrix $X \in \mathbf { R } ^ { N \times F }$ . After stacking $L$ GNN layers, node representations $H ^ { ( L ) }$ are then used to predict existence of each link $( i , j )$ :
+
+$$
+\hat { y } _ { i j } = \sigma ( s ( h _ { i } ^ { ( L ) } , h _ { j } ^ { ( L ) } ) ) ,
+$$
+
+where $s ( \cdot , \cdot )$ is a function, e.g., inner product or MLP, and $h _ { i } ^ { ( L ) }$ is the representation of the node $i$ from $H ^ { ( L ) }$ .
+
+# 3.2 Neighborhood Overlap-based Heuristic Methods
+
+Heuristic methods for link prediction measure the score of given node pairs based on structural information about the node pairs, e.g., shortest path, degree, and common neighbors. Although GNNs outperform existing traditional heuristic methods in various graph tasks, in link prediction, since GNNs heavily rely on smoothed node features rather than graph structure, the heuristic methods often show competitive performance compared to GNNs. Especially, neighborhood overlap-based heuristic methods are straightforward yet highly effective, even better than GNN models in several datasets, e.g., ogbl-collab and ogbl-ppa. Typical neighborhood overlap-based heuristic methods are Common Neighbors, Resource Allocation (RA) [31], and Adamic Adar [30]. The Common Neighbors method measures the score of link $( u , v )$ by counting the number of common neighbors between node $u$ and $v$ as
+
+$$
+\mathit { S c N } ( u , v ) = \left| \mathcal { N } ( u ) \cap \mathcal { N } ( v ) \right| = \sum _ { k \in \mathcal { N } ( u ) \cap \mathcal { N } ( v ) } 1 .
+$$
+
+The Common Neighbors method is simple and effective, but has a limitation that equally weighs the importance of each common neighbor. To solve this issue, several heuristic methods e.g., Resource Allocation, and Adamic-Adar measure the score for the link by considering the importance of each common neighbor. From the intuition that neighbor nodes with lower degrees are more significant, they give more weight to neighbors with lower degrees. Specifically, Resource Allocation (RA) [31] measures the score of link $( u , v )$ by counting the inverse degrees of common neighbors between node $u$ and $v$ as
+
+$$
+S _ { R A } ( u , v ) = \sum _ { k \in \mathcal { N } ( u ) \cap \mathcal { N } ( v ) } \frac { 1 } { d _ { k } } ,
+$$
+
+where $d _ { k }$ denotes the degree of node $k$ . Adamic-Adar has a relatively decreased penalty for higher degree compared to RA by using the reciprocal logarithm of common neighbors’ degrees between
+
+![](images/09c76c16cea1518b521ed316a7261cfcd630e83900e5fe848689b282756ac108.jpg)  
+Figure 1: The Neo-GNNs framework for link prediction. Neo-GNNs learn useful structural features from an adjacency matrix and estimate similarity scores based on overlapped neighborhoods. (a) Neo-GNNs first generate the structural feature vector $\boldsymbol { x } ^ { s t r u c t } \in \mathbf { R } ^ { N \times 1 }$ from an adjacency matrix $A \in \mathbf { R } ^ { N \times N }$ by using Structural feature generator $\mathcal { F } _ { \theta }$ , i.e., ${ \mathcal { F } } _ { \theta } ( A )$ . Then to consider only features of overlapped neighbors between nodes, (b) Neo-GNNs construct a diagonal matrix $X ^ { s t r u c t } \in \mathbf { R } ^ { N \times N }$ and (c) aggregate the features of multi-hop neighborhoods by multiplying the sum of powers of adjacency matrices, i.e., $\textstyle \sum _ { l = 1 } ^ { L } { \beta ^ { l - 1 } } A ^ { l }$ . Finally, two node representations $Z$ and $H$ , respectively from Neo-GNNs and feature-based GNNs, are used to (d) compute similarity scores and combined adaptively with the learnable parameter $\alpha$ .
+
+node $u$ and $v$ as
+
+$$
+S _ { A A } ( u , v ) = \sum _ { k \in \mathcal { N } ( u ) \cap \mathcal { N } ( v ) } \frac { 1 } { \log d _ { k } } .
+$$
+
+These heuristic methods show comparable performance to GNNs for link prediction.
+
+However, they have two limitations. First, each heuristic method uses manually designed structural features of neighborhoods, e.g., 1, $\textstyle { \frac { 1 } { d } }$ , $\frac { 1 } { \log d }$ . This requires the manual choice by domain experts to select the best heuristic method for each dataset. Second, they only consider structural similarity. While the GNNs do not use graph structures well compared to using node features, heuristic methods cannot utilize the node features for link prediction.
+
+To address the limitations of both GNNs and heuristic methods, we propose Neighborhood Overlapaware Graph Neural Networks (Neo-GNN), that learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction, and adaptively combine with the conventional feature-based GNNs in an end-to-end fashion.
+
+# 3.3 Neighborhood Overlap-aware Graph Neural Networks
+
+We now introduce Neighborhood Overlap-aware Graph Neural Networks (Neo-GNNs) for link prediction. We first explain how Neo-GNNs learn and utilize structural information for link prediction and then explain the process of adaptively combining with the feature-based GNNs.
+
+Neo-GNNs consist of two key components: (1) Structural feature generator and (2) neighborhood overlap-aware aggregation scheme. First, as we discussed in section 3.2, each heuristic method uses manually designed structural features of neighborhoods, 1, $\textstyle { \frac { 1 } { d } }$ , $\frac { 1 } { \log d }$ . To generalize and learn these structural features, we propose Structural feature generator $\mathcal { F } _ { \theta }$ which learns to generate structural features of each node using an only adjacency matrix $A \in \mathbf { R } ^ { N \times N }$ of the graph as
+
+$$
+x _ { i } ^ { s t r u c t } = \mathcal { F } _ { \theta } ( A _ { i } ) = f _ { \theta _ { n o d e } } \left( \sum _ { j \in \mathcal { N } _ { i } } f _ { \theta _ { e d g e } } ( A _ { i j } ) \right) ,
+$$
+
+where $x _ { i } ^ { s t r u c t }$ is a structural feature value of the node $i$ and $\mathcal { F } _ { \theta }$ is a learnable function comprised of two MLPs, $f _ { \theta _ { n o d e } }$ and $f _ { \theta _ { e d g e } }$ , for nodes and edges, respectively. That is to say, Neo-GNNs take only an adjacency matrix $A$ as an input to generate the most beneficial structural features. This input adjacency matrix $A$ can be replaced with the combination of powers of adjacency matrices. Now, Structural feature generator $\mathcal { F } _ { \theta }$ can generate structural features for each heuristic method. For example, if $f _ { \theta _ { n o d e } }$ is a reciprocal of the logarithm function, i.e., $\begin{array} { r } { f ( x ) = \frac { 1 } { \log x } } \end{array}$ , and $f _ { \theta _ { e d g e } }$ is an identity function, i.e., $f ( x ) = x$ , then Structural feature generator $\mathcal { F } _ { \theta }$ can generate the exactly same structural feature as the features used in Adamic-Adar method.
+
+Based on the generated structural features of each node, the next process is to calculate the similarity score that considers only structural features of overlapped neighbors between given nodes. Note that conventional GNNs cannot compute this score due to two reasons: the normalized adjacency matrix and the lower dimension of hidden representations than the number of nodes (i.e., $d \ll N$ ). The normalized adjacency matrix hinders GNNs counting a number of neighborhoods and the low dimension makes features of each neighborhoods indistinguishable after aggregation, which cannot detect the neighborhoods overlap. We propose the neighborhood overlap-aware aggregation scheme to calculate neighborhood overlap-aware score. First, to maintain the respective features of each node after aggregation, we construct a diagonal matrix $X ^ { s t r u c t } \in \mathbf { R } ^ { N \times N }$ using the structural feature vector $\boldsymbol { x } ^ { s t r u c t } \in \mathbf { R } ^ { N \times 1 }$ as
+
+$$
+X ^ { s t r u c t } = \mathrm { { d i a g } } ( x ^ { s t r u c t } ) .
+$$
+
+Then, to consider the number of overlapped neighbors, we aggregate features of neighborhoods by multiplying an unnormalized adjacency matrix $A$ as
+
+$$
+Z = A X ^ { s t r u c t } .
+$$
+
+Now, each $i$ -th row vector of $Z , z _ { i }$ , involves all the features of node $i$ ’s neighboring nodes individually. If we compute the inner product of two row vectors in $Z$ , then we can compute the scores with the only overlapped neighborhoods, which equals the sum of square of structural feature values of overlapped neighborhoods, i.e., $\begin{array} { r } { z _ { i } ^ { T } z _ { j } = \sum _ { k \in \dot { \mathcal { N } } ( i ) \cap \mathcal { N } ( j ) } \big ( x _ { k } ^ { s t r u c t } \big ) ^ { 2 } } \end{array}$ .
+
+Furthermore, to consider multi-hop overlapped neigbhors, we extend (8) to multi-hop settings as follows:
+
+$$
+Z = g _ { \Phi } \left( \sum _ { l = 1 } ^ { L } \beta ^ { l - 1 } A ^ { l } X ^ { s t r u c t } \right) ,
+$$
+
+where $\beta$ denotes a hyper-parameter controlling how much weight is given to close neighbors versus distant neighbors and $g _ { \Phi }$ is a MLP which controls the scale of representations $Z$ . Since node representations $Z$ are based on only structural information, we compute feature-based node representations H ∈ RN × d 0 using the conventional feature-based GNNs as
+
+$$
+H = \mathbf { G } \mathbf { N } \mathbf { N } ( X , \tilde { A } _ { G N N } ; W ) ,
+$$
+
+where $X \in \mathbf { R } ^ { N \times F }$ denotes the raw feature matrix, $\tilde { A } _ { G N N }$ denotes a normalized adjacency matrix, and $W$ is the parameter for GNNs. Then given a link $( i , j )$ , Neo-GNNs calculate both similarity scores from each representation matrix $Z$ and $H$ and compute the convex combination of two scores by a trainable parameter $\alpha$ as follows:
+
+$$
+\hat { y } _ { i j } = \alpha \cdot \sigma ( z _ { i } ^ { T } z _ { j } ) + ( 1 - \alpha ) \cdot \sigma ( s ( h _ { i } , h _ { j } ) ) ) ,
+$$
+
+Based on (12), we jointly train our proposed model and individual models using three standard (binary) cross-entropy losses
+
+$$
+\mathcal { L } = \sum _ { ( i , j ) \in D } \big ( \lambda _ { 1 } B C E ( \hat { y } _ { i j } , y _ { i j } ) + \lambda _ { 2 } B C E ( \sigma ( z _ { i } ^ { T } z _ { j } ) , y _ { i j } ) + \lambda _ { 3 } B C E ( \sigma ( s ( h _ { i } , h _ { j } ) ) , y _ { i j } ) \big ) ,
+$$
+
+where $B C E ( \cdot , \cdot )$ denotes binary cross entropy loss and $\lambda _ { i }$ are the weights.
+
+Table 1: Statistics and evaluation metrics of OGB link prediction datasets.   
+
+<table><tr><td>Dataset</td><td>#Nodes</td><td>#Edges</td><td>Avg. node deg.</td><td>Density</td><td>Split ratio</td><td>Metric</td></tr><tr><td>OGB-PPA</td><td>576,289</td><td>30,326,273</td><td>73.7</td><td>0.018%</td><td>70/20/10</td><td>Hits @100</td></tr><tr><td>OGB-COLLAB</td><td>235,868</td><td>1,285,465</td><td>8.2</td><td>0.0046%</td><td>92/4/4</td><td>Hits @50</td></tr><tr><td>OGB-DDI</td><td>4,267</td><td>1,334,889</td><td>500.5</td><td>14.67%</td><td>80/10/10</td><td>Hits@20</td></tr><tr><td>OGB-CITATION2</td><td>2,927,963</td><td>30,561,187</td><td>20.7</td><td>0.00036%</td><td>98/1/1</td><td>MRR</td></tr></table>
+
+Computational Complexity. Our proposed model uses the $N \times N$ matrix $X ^ { s t r u c t }$ for neigbhorhood overlap detection, which generally takes $O ( N | \mathcal { E } | _ { L } )$ computational time to compute node representations $Z$ in (9), where $| \mathcal { E } | _ { L }$ denotes a number of edges connected up to $L$ -hop. To solve this high complexity issue, we represent matrices $X ^ { s t r u c t }$ and $Z$ as the sparse matrix form and the computational time becomes just $\bar { O } ( \vert \mathcal { E } \vert _ { L } )$ . Also, as we can pre-compute the set of adjacency matrices $\{ A ^ { l } \} _ { l = 1 } ^ { L }$ in (9), thus there is no additional cost to calculate the powers of the adjacency matrix during training and inference.
+
+# 4 Experiments
+
+In this section, we evaluate the benefits of our method against state-of-the-art models on link prediction benchmarks. Then we analyze the contribution of each component in Neo-GNNs and show how Neo-GNNs can actually generalize and learn neighborhood overlap-based heuristic methods.
+
+# 4.1 Experiment Settings
+
+Datasets. We evaluate the effectiveness of our Neo-GNNs for link prediction on Open Graph Benchmark datasets [41] (OGB) : OGB-PPA, OGB-Collab, OGB-DDI, OGB-Citation2. Note that OGB-Collab contains multiple edges. Detailed statistics of each dataset are summarized in Table 1.
+
+Evaluation. The evaluation for link prediction is based on the ranking performance of positive test edges over negative test edges. Specifically, in OGB-PPA, OGB-Collab, OGB-DDI, each model ranks positive test edges against randomly-sampled negative edges, and computes the ratio of positive test edges that are ranked at K-th place or above (Hits $\ @ \mathrm { K } )$ . In OGB-Citation2, the evaluation metric is Mean Reciprocal Rank (MRR), where the reciprocal rank of the true link among the negative candidates is calculated for each source node, and then the average is taken over all source nodes.
+
+Baselines. To demonstrate the effectiveness of our Neo-GNNs in link prediction, we compare Neo-GNNs with three heuristic link prediction methods, three embedding-based methods, and five GNN-based models. For heuristic methods, we used three well-known neighborhood-overlap based heuristic methods, Common Neighbors, Adamic Adar [30], and Resource Allocation [31]. Without learning process, they predict links by utilizing each designed structural information regarding overlapped neighborhoods. For embedding-based methods, we used Matrix Factorization, Node2Vec [42], and Multi-Layer Perceptron (MLP). Furthermore, we compare our method to GNN-based models, GCN [11], GraphSAGE [26], JK-Net [43], GAT [12], and SEAL [25]. GCN, GraphSAGE, JK-Net, and GAT compute representations for each node and predict target links by measuring the similarity score between the source and target node of the target links. SEAL extracts enclosing subgraphs around target links and predict target links based on representations of the enclosing subgraphs as graph classification.
+
+Implementation Details. We reimplemented neighborhood overlap-based heuristic method,i.e., Common neighbors, Adamic Adar, and Resource allocation from the referenced papers by using PyTorch. For Node2Vec, GCN, GraphSAGE, JK-Net, and GAT, we used the implementation in PyTorch Geometric [44] and the implementation in the official github repository for SEAL. We set the number of layers to 3 and latent dimensionality to 256 for all GNN-based models. To train our method, we used GCN as a feature-based GNN based model and all MLP models in our Neo-GNNs consist of 2 fully connected layers. We jointly trained feature-based GNNs and Neo-GNNs. Since a GNN model requires more epochs for convergence than that of Neo-GNNs on OGB-PPA, and OGB-DDI, we adopted pre-trained GCN to handle this issue. In OGB-Citation2, due to memory issue, we fix the $f _ { \theta _ { e d g e } }$ as the identity function. For fair comparison, we reported performances of all baselines and our Neo-GNNs as the mean and the standard deviation of performances from 10 independent runs, where each seed is from 0 to 9. The experiments are conducted on a RTX 3090 (24GB) and a Quadro RTX (48GB).
+
+Table 2: Link prediction performances $( \% )$ of our Neo-GNNs and baselines on Open Graph Benchmark (OGB) datasets. Each number is the average performance for 10 random initialization of the experiments. OOM denotes ’out of memory’. Bold indicates the second best performance and underline indicates the best performance.   
+
+<table><tr><td>Method</td><td>OGB-PPA</td><td>OGB-COLLAB</td><td>OGB-DDI</td><td>OGB-CITATION2</td></tr><tr><td>Common Neighbors</td><td>27.65 ± 0.00</td><td>50.06 ±0.00</td><td>17.73 ± 0.00</td><td>76.20±0.00</td></tr><tr><td>Adamic Adar</td><td>32.45 ± 0.00</td><td>53.00 ± 0.00</td><td>18.61 ± 0.00</td><td>76.12 ± 0.00</td></tr><tr><td>Resource Allocation</td><td>49.33 ± 0.00</td><td>52.89 ± 0.00</td><td>6.23± 0.00</td><td>76.20 ± 0.00</td></tr><tr><td>Matrix Factorization</td><td>27.83 ± 2.02</td><td>38.74 ± 0.30</td><td>17.92 ± 3.57</td><td>53.08 ± 4.19</td></tr><tr><td>Node2Vec</td><td>17.24 ± 0.76</td><td>41.36 ± 0.69</td><td>21.95 ± 1.58</td><td>53.47 ± 0.12</td></tr><tr><td>MLP</td><td>0.47± 0.05</td><td>19.98 ± 0.96</td><td>N/A</td><td>28.99 ± 0.16</td></tr><tr><td>GCN</td><td>16.98 ± 1.33</td><td>47.01 ± 0.79</td><td>44.60 ± 8.87</td><td>84.79 ± 0.24</td></tr><tr><td>GraphSAGE</td><td>13.93 ± 2.38</td><td>48.60 ± 0.46</td><td>48.01 ± 9.02</td><td>82.64 ± 0.01</td></tr><tr><td>JK-Net</td><td>11.40 ± 2.04</td><td>48.84 ± 0.83</td><td>57.98 ± 6.88</td><td>OOM</td></tr><tr><td>GAT</td><td>OOM</td><td>44.89 ± 1.23</td><td>29.51 ±6.40</td><td>OOM</td></tr><tr><td>SEAL</td><td>48.15 ± 4.17</td><td>54.37 ± 0.02</td><td>26.25 ±6.00</td><td>86.32 ± 0.52</td></tr><tr><td>Neo-GNN</td><td>49.13 ± 0.60</td><td>57.52 ± 0.37</td><td>63.57 ± 3.52</td><td>87.26 ± 0.84</td></tr></table>
+
+# 4.2 Results on Link Prediction
+
+Table 2 shows link prediction results of the baselines and Neo-GNNs on Open Graph Benchmark (OGB) datasets. We use GCN to adaptively combine with Neo-GNNs across all datasets except OGBCitation2. In OGB-Citation2, since GCN requires 46 GB memory to train, we trained our Neo-GNNs without GCN. As shown in Table 2, we can observe that Neo-GNNs consistently achieve state-ofthe-arts performance across all datasets. Especially, Neo-GNNs show significant improvements on OGB-Collab and OGB-DDI, where the improvements of Neo-GNNs over the best baseline are $5 . 4 \%$ and $9 . 6 \%$ , respectively. Furthermore, note that Neo-GNNs achieved state-of-the-art performance in OGB-Citation2 without GCN, that is, by using only graph structures without input node features. Interestingly, conventional feature-based GNNs show poor performance with a huge gap than that of neighborhood overlap-based heuristic methods on OGB-PPA and OGB-Collab. This implies that feature-based GNNs have a difficulty in directly utilizing structural information e.g., degree and overlapped neighbors, for link prediction. According to this implication, Neo-GNNs and SEAL are able to learn structural information, thus these methods accomplish better performance than conventional GNNs do. Moreover, Neo-GNNs and SEAL even show good performance compared to the heuristic methods in all datasets as they can capture structural information that the heuristic methods utilize. Although SEAL shows good performance compared to heuristic methods, SEAL shows poor performance than feature-based GNNs in OGB-DDI. One possible interpretation is that SEAL cannot adaptively utilize the input node features and structural features according to each data. Instead, Neo-GNNs adaptively combine Neo-GNNs and GCN for each dataset using the learnable parameter $\alpha$ , which shows even higher performance than each performance of Neo-GNNs and GCN. We further analyze the effectiveness of $\alpha$ in 4.2
+
+# 4.3 Ablation Studies
+
+We present ablation experiments to identify the benefits of different components of Neo-GNNs. First, we evaluate our Neo-GNNs without GCN and examine the effectiveness of the parameter $\alpha$ that adaptively combine scores from Neo-GNNs and GCN. Then we study the effects of considering multihop overlapped neighborhoods. Specifically, we investigate the effectiveness of two hyper-parameters, the decaying factor $\beta$ and the maximum hop $L$ , related to multi-hop overlapped neighborhoods.
+
+Table 3: Ablation study analyzing the significance of Neo-GNNs on the OGB-PPA, OGB-Collab, OGB-DDI, and OGB-Citation2 datasets for link prediction. $\alpha$ denotes the attention weight of Neo-GNNs’ scores.   
+
+<table><tr><td>Dataset</td><td>α</td><td>Neo-GNN (w/ GCN)</td><td>Neo-GNN (w/o GCN)</td><td>GCN</td></tr><tr><td>PPA</td><td>0.98 ± 0.003</td><td>49.13 ± 0.60</td><td>48.63 ± 0.88</td><td>16.98 ± 1.33</td></tr><tr><td>COLLAB</td><td>0.57 ± 0.130</td><td>57.52 ± 0.37</td><td>55.70 ± 0.24</td><td>47.01 ± 0.79</td></tr><tr><td>DDI</td><td>0.48 ± 0.015</td><td>63.57 ± 3.52</td><td>17.38 ± 4.05</td><td>44.60 ± 8.87</td></tr><tr><td>CITATION2</td><td>N/A</td><td>0OM</td><td>87.26 ± 0.84</td><td>84.79 ± 0.24</td></tr></table>
+
+![](images/19fdc09cfde826ac8942b6d759e51cb35f51a84e97b747f08e2badb452f619b2.jpg)  
+Figure 2: Link prediction results on the OGB-Collab dataset by varying the maximum hop $L$ (left) and the decaying factor $\beta$ (right).
+
+Neo-GNNs without GCN. To measure the effectiveness of Neo-GNNs itself, we perform an ablation study on four datasets, as shown in Table 3. We can see that Neo-GNNs (w/o GCN) still show the state-of-the-art performances compared to baselines except OGB-DDI. Note that Neo-GNNs (w/o GCN) only use graph structures and outperform other GNNs whereas other GNNs use both input features and graph structures. This shows that utilizing key structrual information about overlapped neighbors is crucial for link prediction.
+
+Effectiveness of the parameter $\alpha$ . To consider both structural information and input features, our proposed model predict similarity scores from the convex combination of two scores from Neo-GNNs and GCN by the trainable parameter $\alpha$ . As shown in Table 3, $\alpha$ varies for each dataset, which indicates that $\alpha$ properly adjusts the weight of structural information and features for each dataset. With the combining process, Neo-GNNs (w/ GCN) consistently show better performance than performances of individual model, i.e., Neo-GNN (w/o GCN) and GCN. Especially, in OGB-DDI, Neo-GNN (w/o GCN) and GCN show less than 50, but the combined model Neo-GNN (w/ GCN) shows $42 \%$ and $80 \%$ improved performance compared to each model.
+
+Effectiveness of multi-hop overlapped neighborhoods. We study the effectiveness of multi-hop overlapped neighborhoods by investigating effects of two hyper-parameters, $L$ and $\beta$ , on OGB-Collab dataset. First, as shown in Figure 2, if Neo-GNNs only consider 1-hop ovelapped neighbhors, i.e., $L = 1$ , Neo-GNNs converge faster than other cases considering multi-hop overlapped neighbors. However, the best performance is lower than the others, which shows that multi-hop overlapped neighborhoods enhance the performance of Neo-GNNs for link prediction. Second, $\beta$ controls how much to reduce the effects of neighborhoods when the distance increases. As shown in Figure 2, as $\beta$ decreases, Neo-GNNs converge slowly but eventually show similar performance. This means that if multi-hop overlapped neighbors are informative, then Neo-GNNs achieve good performance robustly to the value of $\beta$ .
+
+# 4.4 Analysis on learning neighborhood overlap-based heuristic methods
+
+As we discussed in Sec 3.3, our Neo-GNNs generalize several neighborhood overlap-based heuristic methods, (e.g., Common Neighbors, Adamic Adar, and Resource Allocation). Further, in this section, we show that Neo-GNNs (w/o GCN) directly learn each neighbhorhood overlap-based heuristic method and implicitly learn the best one among three heuristic methods on OGB-PPA dataset. We first trained Neo-GNNs to fit the scores from each heuristic method on the train set of OGB-PPA. Then we measure the Spearman correlations by using ranks of test edges from each model. We analyze rank correlations between Neo-GNNs and three heuristic methods based on 50000 sampled test edges in Figure 3. As shown in Figure 3, Neo-GNNs show a strong correlation with other heuristic methods. That is, Neo-GNNs can learn each heuristic method. Next, to show that Neo-GNNs learn the most desirable heuristic method depending on datasets, we compute Spearman correlations between ranks from trained Neo-GNNs on OGB-PPA dataset and the heuristic methods. As a result, correlation scores between Neo-GNNs and Resource Allocation, Adamic Adar, and Common Neighbors are 0.9627, 0.9277, and 0.8982, respectively. We can see that correlation scores are proportional to performances of each heuristic method (49.33, 32.45, and 27.65), which learn the best heuristic method.
+
+![](images/692e5a685e638c68cb8e31f7dbca25df06abc85b6950dcf5f84e9e12d9c99021.jpg)  
+Figure 3: Comparison of rank correlation between our Neo-GNNs and three neighborhood overlapbased heuristic methods on OGB-PPA. We evaluate a rank correlation on positive test edges after ranking the entire test edge prediction scores. We visualize a rank correlation using randomly sampled 50,000 positive test edges. The 3(a), 3(b), and 3(c) show rank correlation when Neo-GNNs (w/o GCN) fit to scores of each heuristic method. The 3(d), 3(e), and 3(f) present the rank correlation between Neo-GNNs (w/o GCN) and each heuristic method upon OGB-PPA. The number in parentheses indicates Spearman Correlation coefficient.
+
+# 5 Conclusion
+
+We introduced Neighborhood Overlap-based Graph Neural Networks (Neo-GNNs) that learn and utilize structural information, which is a key element in link prediction. Neo-GNNs learn useful structural features from an adjacency matrix and estimate overlapped neighborhoods for link prediction. We also adaptively combine Neo-GNNs and feature-based GNNs to consider both structural features and input node features. Furthermore, our Neo-GNNs generalize several neigbhorhood overlap-based heuristic methods and handle overlapped multi-hop neigbhorhoods. Extensive experiments on four Open Graph Benchmark (OGB) datasets demonstrate that Neo-GNNs consistently acheive stateof-the-art performance on four OGB datasets in link prediction. In future work, we plan to further develop Neo-GNNs to generalize more link prediction-based heuristic methods and improve the scalability with efficient sparse matrix computation.
+
+# 6 Acknowledgement
+
+This work was supported by the following funding sources: National Research Foundation of Korea (NRF-2020R1A2C3010638, NRF-2014M3C9A3063541); ICT Creative Consilience program(IITP2021-2020-0-01819) supervised by the IITP; Samsung Research Funding & Incubation Center of Samsung Electronics under Project Number SRFC-IT1701-51.
+
+# References
+
+[1] Jiezhong Qiu, Jian Tang, Hao Ma, Yuxiao Dong, Kuansan Wang, and Jie Tang. Deepinf: Social influence prediction with deep learning. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining (KDD), pages 2110–2119, 2018.   
+[2] Lei Tang and Huan Liu. Graph mining applications to social network analysis. In Managing and Mining Graph Data, pages 487–513. Springer, 2010.   
+[3] Hao Wang, Tong Xu, Qi Liu, Defu Lian, Enhong Chen, Dongfang Du, Han Wu, and Wen Su. Mcne: An end-to-end framework for learning multiple conditional network representations of social network. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery Data Mining (KDD), pages 1064–1072, 2019.   
+[4] Nicola De Cao and Thomas Kipf. Molgan: An implicit generative model for small molecular graphs. arXiv preprint arXiv:1805.11973, 2018.   
+[5] David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alan Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in Neural Information Processing Systems (NeurIPS) 28, pages 2224–2232. Curran Associates, Inc., 2015.   
+[6] Alex Fout, Jonathon Byrd, Basir Shariat, and Asa Ben-Hur. Protein interface prediction using graph convolutional networks. In Advances in Neural Information Processing Systems (NeurIPS) 30, pages 6530–6539. Curran Associates, Inc., 2017.   
+[7] Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. In Proceedings of the 34th International Conference on Machine Learning, Proceedings of Machine Learning Research, pages 1263– 1272, 2017.   
+[8] Helisa Dhamo, Azade Farshad, Iro Laina, Nassir Navab, Gregory D. Hager, Federico Tombari, and Christian Rupprecht. Semantic image manipulation using scene graphs. In The IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 5213–5222, 2020.   
+[9] Charles R Qi, Hao Su, Kaichun Mo, and Leonidas J Guibas. Pointnet: Deep learning on point sets for 3d classification and segmentation. In Proceedings of the IEEE conference on computer vision and pattern recognition, pages 652–660, 2017.   
+[10] Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph cnn for learning on point clouds. Acm Transactions On Graphics (tog), 38(5):1–12, 2019.   
+[11] Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In International Conference on Learning Representations, 2017.   
+[12] Petar Velickovi ˇ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua ´ Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903, 2017.   
+[13] Johannes Klicpera, Stefan Weiß enberger, and Stephan Günnemann. Diffusion improves graph learning. In Advances in Neural Information Processing Systems (NeurIPS) 32, pages 13333–13345. Curran Associates, Inc., 2019.   
+[14] Ming Chen, Zhewei Wei, Zengfeng Huang, Bolin Ding, and Yaliang Li. Simple and deep graph convolutional networks. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 1725–1735, 2020.   
+[15] Cheng Zheng, Bo Zong, Wei Cheng, Dongjin Song, Jingchao Ni, Wenchao Yu, Haifeng Chen, and Wei Wang. Robust graph representation learning via neural sparsification. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 11458–11468, 2020.   
+[16] Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 32, 2018.   
+[17] Rex Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. arXiv preprint arXiv:1806.08804, 2018.   
+[18] Junhyun Lee, Inyeop Lee, and Jaewoo Kang. Self-attention graph pooling. In Kamalika Chaudhuri and Ruslan Salakhutdinov, editors, Proceedings of the 36th International Conference on Machine Learning. PMLR, 2019.   
+[19] Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826, 2018.   
+[20] Seongmin Ok. A graph similarity for deep learning. In Advances in Neural Information Processing Systems (NeurIPS) 33, pages 1–12. Curran Associates, Inc., 2020.   
+[21] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Junction tree variational autoencoder for molecular graph generation. In International Conference on Machine Learning, pages 2323–2332. PMLR, 2018.   
+[22] Wengong Jin, Regina Barzilay, and Tommi Jaakkola. Hierarchical generation of molecular graphs using structural motifs. In Proceedings of the 37th International Conference on Machine Learning (ICML), pages 4839–4848, 2020.   
+[23] Jenny Liu, Aviral Kumar, Jimmy Ba, Jamie Kiros, and Kevin Swersky. Graph normalizing flows. In Advances in Neural Information Processing Systems (NeurIPS) 32, pages 13556–13566. Curran Associates, Inc., 2019.   
+[24] Jiaxuan You, Bowen Liu, Rex Ying, Vijay Pande, and Jure Leskovec. Graph convolutional policy network for goal-directed molecular graph generation. In Advances in Neural Information Processing Systems (NeurIPS) 31, pages 6412–6422. Curran Associates, Inc., 2018.   
+[25] Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. In Advances in Neural Information Processing Systems, pages 5165–5175, 2018.   
+[26] William Hamilton, Rex Ying, and Jure Leskovec. Inductive representation learning on large graphs. In I. Guyon, U. V. Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett, editors, Advances in Neural Information Processing Systems 30, pages 1024–1034. Curran Associates, Inc., 2017.   
+[27] Haggai Maron, Heli Ben-Hamu, Nadav Shamir, and Yaron Lipman. Invariant and equivariant graph networks. In International Conference on Learning Representations, 2018.   
+[28] Jiaxuan You, Rex Ying, and Jure Leskovec. Position-aware graph neural networks. In International Conference on Machine Learning, pages 7134–7143. PMLR, 2019.   
+[29] Albert-László Barabási and Réka Albert. Emergence of scaling in random networks. science, 286(5439):509–512, 1999.   
+[30] Lada A Adamic and Eytan Adar. Friends and neighbors on the web. Social networks, 25(3):211– 230, 2003.   
+[31] Tao Zhou, Linyuan Lü, and Yi-Cheng Zhang. Predicting missing links via local information. The European Physical Journal B, 71(4):623–630, 2009.   
+[32] Leo Katz. A new status index derived from sociometric analysis. Psychometrika, 18(1):39–43, 1953.   
+[33] Sergey Brin and Lawrence Page. Reprint of: The anatomy of a large-scale hypertextual web search engine. Computer networks, 56(18):3825–3833, 2012.   
+[34] Glen Jeh and Jennifer Widom. Simrank: a measure of structural-context similarity. In Proceedings of the eighth ACM SIGKDD international conference on Knowledge discovery and data mining, pages 538–543, 2002.   
+[35] Yehuda Koren, Robert Bell, and Chris Volinsky. Matrix factorization techniques for recommender systems. Computer, 42(8):30–37, 2009.   
+[36] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pages 701–710, 2014.   
+[37] Jiezhong Qiu, Yuxiao Dong, Hao Ma, Jian Li, Kuansan Wang, and Jie Tang. Network embedding as matrix factorization: Unifying deepwalk, line, pte, and node2vec. In Proceedings of the eleventh ACM international conference on web search and data mining, pages 459–467, 2018.   
+[38] Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. Efficient estimation of word representations in vector space. arXiv preprint arXiv:1301.3781, 2013.   
+[39] Elena Zheleva and Lise Getoor. To join or not to join: The illusion of privacy in social networks with mixed public and private user profiles. In Proceedings of the 18th International Conference on World Wide Web, WWW ’09, page 531–540, 2009.   
+[40] Thomas N Kipf and Max Welling. Variational graph auto-encoders. arXiv preprint arXiv:1611.07308, 2016.   
+[41] Weihua Hu, Matthias Fey, Marinka Zitnik, Yuxiao Dong, Hongyu Ren, Bowen Liu, Michele Catasta, and Jure Leskovec. Open graph benchmark: Datasets for machine learning on graphs. arXiv preprint arXiv:2005.00687, 2020.   
+[42] Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pages 855–864, 2016.   
+[43] Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. In International Conference on Machine Learning, pages 5453–5462. PMLR, 2018.   
+[44] Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019.

parse/train/SJgCEpVtvr/SJgCEpVtvr.md

@@ -0,0 +1,281 @@
+# DYNAMIC SELF-TRAINING FRAMEWORK FOR GRAPH CONVOLUTIONAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graph neural networks (GNN) such as GCN, GAT, MoNet have achieved stateof-the-art results on semi-supervised learning on graphs. However, when the number of labeled nodes is very small, the performances of GNNs downgrade dramatically. Self-training has proved to be effective for resolving this issue, however, the performance of self-trained GCN is still inferior to that of G2G and DGI for many settings. Moreover, additional model complexity make it more difficult to tune the hyper-parameters and do model selection. We argue that the power of self-training is still not fully explored for the node classification task. In this paper, we propose a unified end-to-end self-training framework called Dynamic Self-traning, which generalizes and simplifies prior work. A simple instantiation of the framework based on GCN is provided and empirical results show that our framework outperforms all previous methods including GNNs, embedding based method and self-trained GCNs by a noticeable margin. Moreover, compared with standard self-training, hyper-parameter tuning for our framework is easier.
+
+# 1 INTRODUCTION
+
+Graphs or networks can be used to model any interactions between entities such as social interactions (Facebook, Twitter), biological networks (protein-protein interaction), and citation networks. There has been an increasing research interest in deep learning on graph structured data, e.g., (Bruna et al., 2014; Defferrard et al., 2016; Monti et al., 2017; Kipf & Welling, 2017; Hamilton et al., 2017; Velickovic et al., 2018; Tang et al., 2015; Perozzi et al., 2014).
+
+Semi-supervised node classification on graphs is a fundamental learning task with many applications. Classic methods rely on some underly diffusion process to propagate label information. Recently, network embedding approaches have demonstrate outstanding performance on node classification (Tang et al., 2015; Grover & Leskovec, 2016; Bojchevski & Günnemann, 2018). This approach first learns a lower-dimensional embedding for each node in an unsupervised manner, and then the embeddings are used to train a supervised classifier for node classification, e.g., logistic regression or multi-layer perceptron (MLP). Graph neural networks (GNN) are semi-supervised models and have achieved state-of-the-art performance on many benchmark data sets (Monti et al., 2017; Kipf & Welling, 2017; Velickovic et al., 2018). GNNs generalize convolution to graph structured data and typically have a clear advantage when the number of training examples is reasonably large. However, when there are very few labeled nodes, GNNs is outperformed by embedding based method (as shown by our experimental results), e.g., G2G from (Bojchevski & Günnemann, 2018) and DGI from (Velickovi ˇ c et al., 2019). ´
+
+To overcome this limitation of GCNs (Kipf & Welling, 2017), Li et al. (Li et al., 2018) propose to apply self-training and co-training techniques (Scudder, 1965). The idea of these techniques is to augment the original training set by adding in some unlabeled examples together with their label predictions. Such “pseudo-label” information is either from the base model trained on the original training set (self-training) or another learning algorithm (co-training). The results from (Li et al., 2018) demonstrate the effectiveness of co-training and self-training. However, among the four variants implemented in (Li et al., 2018), there is not a single one that achieves the best performance across different settings; and from our experiments, G2G and DGI outperforms all the four variants when the number of labels from each class is less than 10. There are clear restrictions in prior self-training approaches. First, the pseudo-label set is incremental only, i.e., after an unlabeled example is added to the training set, it will never be deleted and its pseudo-label will never change even if its prediction and/or the corresponding margin has changed drastically. Secondly, all the pseudo-labels are considered equal, although they may have very different classification margins. Furthermore, it introduces extra hyper-parameters such as the number of unlabeled nodes to be added into the training set and the total number of self-training iterations. The performance gain is sensitive to such parameters and their optimal values may differ for different data sets and label rates (Buchnik & Cohen, 2018).
+
+To fully understand and explore the power of self-training on the node classification task, we propose a novel self-training framework, named Dynamic Self-training, which is general, flexible, and easy to use. We provide a simple instantiation of the framework based on GCN (Kipf & Welling, 2017) and empirically show that it outperforms state-of-art methods including GNNs, self-trained GCN (Li et al., 2018), and embedding based methods. Our framework has the following distinguishing features compared with (Li et al., 2018; Buchnik & Cohen, 2018).
+
+1. We augment the training set and recalculate the pseudo-labels after each epoch. So the number self-training iterations is the same as the number of epochs and the pseudo-label assigned to an unlabeled example may change during the training process.   
+2. In stead of inserting a fixed number of new pseudo-labels with highest margin in each iteration, we use a threshold-based rule, i.e., insert an unlabeled node if and only if its classification margin is above the threshold.   
+3. The pseudo-label set is dynamic. When the margin of an unlabeled node is above the threshold, we activate it by adding it to the loss function, but if the margin of this node becomes lower than the threshold in a later epoch, we will deactivate it.   
+4. We assign a (dynamic) personalized weight to each active pseudo-label proportional to its current classification margin. The total pseudo-label loss is thus the weighted sum of losses corresponds to all pseudo-labels.
+
+# 2 PRELIMINARIES
+
+# 2.1 GRAPH NOTATION AND PROBLEM DEFINITION
+
+In the problem, we are given an undirected graph with node attributes $G = ( V , E , X )$ , where $V$ is the vertex set, $E$ is the edge set. Here, $X$ is the feature matrix, the $i$ -th row of which, denoted as $x _ { i }$ , is the feature vector of node $i$ . We assume each node belongs to exactly one class and use $y _ { i }$ to denote the class label of the $i$ -th node. The aim is to design learning algorithms to predict the labels of all nodes based on the labels of a small set of training nodes provided in the beginning. We use $\mathcal { N } _ { k } ( i )$ to denote the set of nodes whose distance to node $i$ is at most $k$ . $\mathcal { L } \subset V$ is the set of labeled nodes and $\mathcal { U } = V \setminus \mathcal { L }$ is the set of unlabeled nodes.
+
+# 2.2 GRAPH CONVOLUTIONAL NETWORKS
+
+GCN introduced in (Kipf & Welling, 2017) is a graph neural network model for semi-supervised classification. GCN learns the representations of each node by iteratively aggregating the embeddings of its neighbors. Specifically, GCN consists of $L > 0$ layers each with the same propagation rule defined as follows. In the $l$ -th layer, the hidden representations $H ^ { ( l - 1 ) }$ are averaged among one-hop neighbors as:
+
+$$
+H ^ { ( l ) } = \sigma ( \tilde { D } ^ { - \frac { 1 } { 2 } } \tilde { A } \tilde { D } ^ { - \frac { 1 } { 2 } } H ^ { ( l - 1 ) } W ^ { ( l ) } ) .
+$$
+
+Here, ${ \tilde { A } } = A + I _ { n }$ is the adjacency matrix of $G$ after adding self-loops ( $I _ { n }$ is the identity matrix), $\tilde { D }$ is a diagonal matrix with $\tilde { D _ { i i } } = \dot { \sum _ { j } { A _ { i j } } }$ , $W ^ { ( l ) }$ is a trainable weight matrix of the $l$ -th layer, and $\sigma$ is a nonlinear activation function; $\dot { H ^ { ( l ) } } \in \mathbb { R } ^ { n \times d _ { l } }$ denotes hidden feature matrix of the $l$ -th layer and $H ^ { ( 0 ) } = X$ and $f _ { i } = H _ { i } ^ { ( L ) }$ represents the output of $i$ -th node.
+
+We use $l ( y _ { i } , f _ { i } )$ to denote the classification loss of node $i$ , which is typically the cross entropy function. Thus, loss function used by GCN is of the form:
+
+$$
+L = \sum _ { i \in \mathcal { L } } l ( y _ { i } , f _ { i } )
+$$
+
+For a $k$ -layer GCN, the receptive field of each training example is its order- $k$ neighborhood. When there are only few training samples, we need to increase the number of layers in order to cover most of the unlabeled nodes. However, deeper GCN will cause the problem of over-smoothing, i.e., critical features of the vertices may be smoothed through the iterative averaging process, which makes nodes from different class indistinguishable (Xu et al., 2018; Li et al., 2018).
+
+# 2.3 SELF TRAINING
+
+Recently (Li et al., 2018) apply self-training to overcome these limitations of GCNs. Self-training is a natural and general approach to semi-supervised learning, which is particularly well-motivated in the context of node classification (Buchnik & Cohen, 2018; Li et al., 2018). Assume we have a base model/algorithm for the learning problem, which takes as input a set of labeled examples and makes predictions for other examples. Typically, for each unlabeled node, the base algorithm will also return an associated margin or confidence score. The self-training framework trains and applies the base model in rounds, where at the end of each round, the highest-confidence predictions are converted to become new labeled examples in the next round of training and prediction. Thus, the receptive fields of all the labeled nodes increases and will eventually cover the entire graph, which resolve the issue of GCNs without adding more layers.
+
+# 3 OUR METHOD
+
+# 3.1 A GENERALIZED SELF-TRAINING FRAMEWORK
+
+# Algorithm 1: Dynamic Self-training Framework
+
+1 Generate initial parameter $\theta ^ { 0 }$ for model $f ( \cdot , \cdot )$ , and the initial confidence score vector $S _ { V }$ .   
+2 for each epoch $t = 1 , 2 , . . . , T$ do   
+3 Compute prediction $f _ { V } \gets f ( G , \theta ^ { t - 1 } )$   
+4 Update confidence score $S _ { V }  { \mathcal { U C } } ( f _ { V } )$ .   
+5 Update model parameter by confidence score. $\theta ^ { t } \gets \mathcal { U P } ( f _ { V } , S _ { V } , f )$   
+6 if stopping criteria is met then   
+7 Break   
+8 end   
+9 end
+
+Sun et al. (Sun et al., 2019) proposed Multi-stage Training Framework as generalization for selftraining method in (Li et al., 2018). Inspired by this, we propose a more generalized end-to-end self-training framework named Dynamic Self-training Framework shown in algorithm 1. Instead of operating on data split, we maintain a confidence score in each iteration. There is no specified training stages here, but we update the confidence value for each unlabeled node after every epoch.
+
+Consider the original model $f ( \cdot , \cdot )$ as a forward predicting function with backward trainable parameters. The graph data $G$ and the trainable parameters $\theta ^ { t }$ is the input of this function, and the output of this model is collected into $f _ { V } \in \mathbb { R } ^ { n \times C }$ , where $f _ { v }$ denotes the output vector (before assigned with label) of node $v \in V$ , and $C = d _ { L }$ is the number of classes. Then we construct the confidence score vector $S _ { V } \in \mathbb { R } ^ { n }$ from the model output $f _ { v }$ using a function $\mathcal { U } \mathcal { C }$ , which can be instantiated in many forms. For example, Algorithm 2 illustrates how standard multi-stage self-training GCN implement this part. Finally we update the model parameters using a specified algorithm such as gradient descent, where the confidence score vector plays a role. The confidence score participates in the parameter updating process in an end-to-end manner. An example of this part can be seen in section 3.3.
+
+# 3.2 PSEUDO LABEL METHOD
+
+Define the pseudo label $\tilde { y } _ { i } \in \mathbb { R } ^ { d _ { L } }$ of $i$ -th node which satisfies :
+
+$$
+\tilde { y } _ { i j } = \left\{ \begin{array} { l l } { 1 } & { \mathrm { i f ~ } j = \arg \operatorname* { m a x } _ { j ^ { \prime } } f _ { i j ^ { \prime } } } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right.
+$$
+
+# Algorithm 2: Update confidence score for Multi-stage Self-training GCN
+
+<table><tr><td colspan="2">if the stage is currently switched then</td></tr><tr><td>2</td><td>for each class k do</td></tr><tr><td>3</td><td>Find the top m vertices v in fv and v ∈U</td></tr><tr><td>4</td><td>Change the value of v in Sv to 1</td></tr><tr><td>5</td><td>end</td></tr><tr><td>6</td><td>return Sv</td></tr><tr><td colspan="2">7 end</td></tr></table>
+
+(Lee, 2013) introduced a pseudo label version of semi-supervised losses:
+
+$$
+L = \sum _ { i \in \mathcal { L } } l ( y _ { i } , f _ { i } ) + \lambda \sum _ { i \in \mathcal { U } } l ( \tilde { y } _ { i } , f _ { i } ) ,
+$$
+
+where $\begin{array} { r } { \lambda = \frac { n } { n ^ { \prime } } \gamma } \end{array}$ , $n = | \mathcal { L } |$ , $n ^ { \prime } = | \boldsymbol { \mathcal { U } } |$ , $\gamma \in \mathbb R$ is a hyper-parameter and the additive term $\textstyle \sum _ { i \in { \mathcal { U } } } l ( { \tilde { y } } _ { i } , f _ { i } )$ is the pseudo label loss. Here, $\lambda$ measures how much the pseudo label term influence the training process. This is equivalent to Entropy Regularization for classification problems (Lee, 2013).
+
+# 3.3 SOFT LABEL CONFIDENCE
+
+In standard multi-stage self-training methods, a node just has two states: in the training set or not, which corresponds to binary-valued confidences $\{ 0 , 1 \}$ ; and in most cases, if a node is added in training set, it will be kept there. This simple setting hinders learning in some cases. For instance, if the classifier puts a wrongly labeled node into the training set, which is of high possibility in preliminary training epochs, it will persistently learn wrong knowledge from this node. Worse still, another wrongly adding is more possible. This negative feedback loop may contribute to a extremely poor classifier. Moreover, original labeled nodes and added nodes in the training are treated equally, which is too restricted and may harm the learning; explicitly distinguishing them in the training process could be beneficial. To resolve these problems, we introduce a mechanism named Soft Label Confidence as the confidence updating component in algorithm 1, which computes a personalized confidence value for each node, and the training set is dynamically changing except the ground truth labels. Based on the pseudo label loss (4), we propose the loss wrapped by soft label confidence:
+
+$$
+L = \sum _ { i \in \mathcal { L } } l ( y _ { i } , f _ { i } ) + \lambda \sum _ { i \in \mathcal { U } } \alpha ( f _ { i } ) l ( \tilde { y } _ { i } , f _ { i } ) .
+$$
+
+Here $\alpha$ is a function mapping from $\mathbb { R } ^ { d _ { L } }$ to $\mathbb { R }$ , defined as confidence function. While there are other possible choices for $\alpha$ , in our method we adopt a threshold based function:
+
+$$
+\alpha ( f _ { i } ) = \frac { 1 } { n _ { c ^ { i } } ^ { \prime } } \mathrm { m a x } ( \mathrm { R e L U } ( f _ { i } - \beta \cdot { \bf 1 } ) ) ,
+$$
+
+Here $\beta \in ( 0 , 1 )$ is a hyper-parameter as threshold, $n _ { c ^ { i } } ^ { \prime }$ denotes the number of nodes whose pseudo label belongs to class $c ^ { i }$ , $c ^ { i }$ is the class which $i$ -th node’s pseudo label belongs to, and 1 is the all 1 vector. We introduce $n _ { c ^ { i } } ^ { \prime }$ here to balance the categories of pseudo labels, because pseudo labels could be initially extremely unbalanced and lead to a poor classifier in practice.
+
+Although $\alpha ( f _ { i } )$ depends on $f _ { i }$ , and thus a function of network’s weights, we will block the flow of gradient through $\alpha ( f _ { i } )$ for the following reasons: Firstly, confidence function is non-differentiable in most cases. Secondly, if we allow the gradient to flow through $\alpha ( f _ { i } )$ , the optimizer may tend to find a solution that satisfies $\operatorname* { m a x } ( f _ { i } ) < \beta , \mathsf { \bar { \forall } } i \in V$ , since for such a solution, $\overset { \vartriangle } { \alpha { \left( f _ { i } \right) } } = 0$ for all $i$ and the pseudo label loss is zero, which does no good to self-supervised learning. So we use the following way to compute the gradient:
+
+$$
+\frac { \partial L } { \partial W _ { s , t } ^ { l } } = \sum _ { i \in \mathcal { L } } \frac { \partial l ( y _ { i } , f _ { i } ) } { \partial W _ { s , t } ^ { l } } + \lambda \sum _ { i \in \mathcal { U } } \alpha ( f _ { i } ) \frac { \partial l ( \tilde { y } _ { i } , f _ { i } ) } { \partial W _ { s , t } ^ { l } }
+$$
+
+# 4 RELATED WORK
+
+Graph Convolutional Network The work of GNNs seeks generalizations of the convolution operator to graph structured data. One way to do this is to apply convolution in the spectral domain, where the eigenvectors of the graph Laplacian are considered as the Fourier basis (Bruna et al., 2014; Henaff et al., 2015; Defferrard et al., 2016; Kipf & Welling, 2017). Such spectral methods learns hidden layer representations that encode both graph structure and node features simultaneously. Kipf and Welling (Kipf & Welling, 2017) simplify previous spectral techniques by restricting the propagation to a 1-hop neighborhood in each layer. (Chen et al., 2018) propose fast GCNs, which improves the training speed of the original GCN. GAT of (Velickovic et al., 2018) allows for assigning different importances to nodes of the same neighborhood via attention mechanisms. (Xu et al., 2018) introduce JK networks, which adjust the influence radii of each node adaptively. Another direction that generalizes convolutions to graph structured data, namely non-spectral approaches, define convolutions directly in the spatial domain (Duvenaud et al., 2015; Atwood & Towsley, 2016; Monti et al., 2017). Such methods are easier to be adapted to do inductive learning (Hamilton et al., 2017; Velickovic et al., 2018; Bojchevski & Günnemann, 2018). However, few-shot learning remains a challenge for this class of methods.
+
+Label Propagation Unlike GNNs, which propagate node representations, the classic Label Propagation (LP) method (Zhu et al., 2003) iteratively propagates (soft) labels. More specifically, in each iteration, each unlabeled node obtains a new soft label that is the aggregation of the soft labels from the previous iteration of its neighbors. The key to LP is to design an effective propagation rule; for some propagation rules, the algorithm may not converge and/or the accuracy may not improve over iterations. Thus, one often needs to specify a stopping criteria and a validation set for model selection. LP can also be used as the base algorithm in the self-training framework.
+
+Self-training Self-training is a natural and general approach to semi-supervised learning (Scudder, 1965) and has been widely used in the NLP literature. Self-training is used by (Yarowsky, 1995; Hearst, 1991) for word sense disambiguation. (Riloff et al., 1999) used self-training in the form of bootstrapping for information extraction and later for learning subjective nouns. (Riloff et al., 2003) with (Nigam et al., 2000) using EM for text classification. Self-training has been used for object recognition (Rosenberg et al., 2005; Zhou et al., 2012). (McClosky et al., 2006; 2008; Huang & Harper, 2009; Sagae, 2010) shows how effective can self-training be in parsing. (Wang et al., 2007; Huang et al., 2009; Qi et al., 2009) introduce self-training techniques to part of speech tagging, and (Kozareva et al., 2005; Liu et al., 2013a) adopt self-training in named entity recognition. (Van Asch & Daelemans, 2016; Drury et al., 2011; Liu et al., 2013b) used self-training in sentiment classification. Recently, self-training has also been successfully applied on node classification. Li et al. (Li et al., 2018) study self-training GCNs; Buchnik and Cohen (Buchnik & Cohen, 2018) mainly consider the effect self-training for diffusion-based techniques. In pseudo-label method of (Lee, 2013), for unlabeled data, their pseudo-labels are recalculated every weights update. However, they don’t assign weight to each unlabeled data.
+
+As for the self-training algorithm itself, (Chen et al., 2011) shows that selecting highly confident instances with a pre-defined threshold may not perform well. (McClosky et al., 2006) produce a ranked list of n-best predicted parses and selected the best one. (Rosenberg et al., 2005) shows that a training data selection metric that is defined independently of the detector greatly outperforms a selection metric based on the detection confidence generated by the detector. (Zhou et al., 2012) suggests that selecting more informative unlabelled data using a guided search algorithm can significantly improve performance over standard self-training framework. Most recently, (Levatic et al., 2017) proposed ´ proposed an algorithm to automatically select appropriate threshold.
+
+Network Embedding Node classification is also one of the main applications of network embedding methods, which learns a lower-dimensional representation for each node in an unsupervised manner, followed by a supervised classifier layer for node classification (Perozzi et al., 2014; Tang et al., 2015; Grover & Leskovec, 2016; Wang et al., 2016; Bojchevski & Günnemann, 2018). A recent work of (Bojchevski & Günnemann, 2018) proposes Graph2Gauss. This method embeds each node as a Gaussian distribution according to a novel ranking similarity based on the shortest path distances between nodes. A distribution embedding naturally captures the uncertainty about the representation. DGI (Velickovi ˇ c et al., 2019) is an embedding method based on GCNs, the unsupervised objective of ´ which is to maximize mutual information. The work of Embedding approaches achieve competitive performance in node classification tasks, while the learned representations also prove to be extremely useful for other downstream applications.
+
+# 5 EVALUATION
+
+# 5.1 DATASET
+
+We conduct the evaluation on four benchmark citation datasets: Cora, Citeseer, Pubmed (Sen et al., 2008), and Core-full (Bojchevski & Günnemann, 2018). Each of these four datasets is undirected graph with node feature. Each node is a document and the edges denote the citation relationship; the feature of a node is the bag-of-words representation of the document. The number of layers in GCN is two by default, and thus the receptive field of each labeled node is its order-2 neighborhood. We measure the fraction of nodes which is covered by the 2-hop neighbors of all labeled nodes, i.e., $| \cup _ { s \in \mathcal { S } } \mathcal { N } _ { 2 } ( s ) | / | V |$ , where $s$ is the set of labeled nodes randomly sampled from $V$ . Here we report the 2-hop coverage ratio on the four datasets when the label rates are $1 \%$ and $0 . 5 \%$ respectively. We summarize the information of datasets in Table 1.
+
+Table 1: Summary of datasets   
+
+<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Cora-full</td></tr><tr><td># of Nodes</td><td>2708</td><td>3327</td><td>19717</td><td>18703</td></tr><tr><td>#of Edges</td><td>5429</td><td>4732</td><td>44338</td><td>81124</td></tr><tr><td>#of Features</td><td>1433</td><td>3703</td><td>500</td><td>8710</td></tr><tr><td># of Classes</td><td>7</td><td>6</td><td>3</td><td>67</td></tr><tr><td>Coverage(0.5%)</td><td>14.78%</td><td>6.64%</td><td>21.58%</td><td>27.19%</td></tr><tr><td>Coverage(1%)</td><td>24.78%</td><td>12.14%</td><td>34.60%</td><td>47.42%</td></tr></table>
+
+# 5.2 EXPERIMENT SETTINGS
+
+We evaluate models on semi-supervised node classification tasks with varying label rates. Instead of evaluating on a fixed data split as in (Kipf & Welling, 2017; Velickovic et al., 2018), we mainly consider random splits as (Li et al., 2018) does. In detail, for a given label rate, we randomly generate 100 different splits on each dataset. In each split, there is a labeled set with prespecified size for training, and in this set each class contains the same number of labeled nodes. As in (Li et al., 2018), we don’t use a validation set, and all the remaining nodes will be used for testing. For simplicity, we will refer to a task in the form of dataset-l, where $l$ is the number of labeled nodes per class. For example, Cora-1 denotes the classification task on dataset Cora with one seed per class.
+
+# 5.3 IMPLEMENTATION DETAILS
+
+For all the models(Perozzi et al., 2014; Tang et al., 2015; Grover & Leskovec, 2016; Wang et al., 2016; Bojchevski & Günnemann, 2018; Velickovic et al., 2018; Monti et al., 2017) except for GCN based methods, settings of hyper-parameters are the same as suggested in original papers. All GCN based methods including GCN, Self-training GCN, Co-training GCN, Intersection GCN, Union GCN, and DSGCN share the same setting of hyper-parameter following (Shchur et al., 2018): one hidden layer with 64 units, dropout rate 0.8, Adam optimizer (Kingma & Ba, 2015) with learning rate $1 0 ^ { - 2 }$ , a $L _ { 2 }$ regularization with weight $1 0 ^ { - 3 }$ . We train other GCN based methods for a fixed epochs of 200, while DSGCN is trained for 600 epochs in few-label tasks such as 1, 3, 5, 10 tasks. Because 20 or 50 labels per class implies ample supervised information, we train DSGCN for 200 epochs in these tasks. The four variants of (Li et al., 2018): Self-training GCN, Co-training GCN, Intersection GCN and Union GCN follow original self-training settings in (Li et al., 2018). For DSGCN, we use a threshold of 0.6 when the number of labels per class is below 3, and set the threshold to 0.75 for label rate above 3 but below 10. Otherwise, the threshold is 0.9 by default.
+
+# 5.4 RESULT ANALYSIS
+
+The numerical results are summarized in Table 2 and Table 3. The highest accuracy in each column is highlighted in bold and the top 3 are underlined. We group all models into three categories: GNN variants(GCN, GAT, MoNet), unsupervised embedding methods (DeepWalk, DGI, LINE, G2G) and GCN with self-training (Co-training, Self-training, Union and Intersection, DSGCN).
+
+Table 2: Summary of results in terms of mean classification accuracy (in percent) over 100 random splits in different tasks. Unsupervised approaches first learn a lower-dimensional embedding for each node in an unsupervised manner, and then the embeddings are used to train a supervised classifier for node classification. Here we use logistic regression as the classifier for unsupervised embeddings.   
+
+<table><tr><td></td><td colspan="6">Citeseer</td><td colspan="6">Cora</td></tr><tr><td># of Labels</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>LP</td><td>30.1</td><td>37.0</td><td>39.3</td><td>41.9</td><td>44.8</td><td>49.5</td><td>51.5</td><td>60.5</td><td>62.5</td><td>64.2</td><td>67.3</td><td>71.7</td></tr><tr><td>DeepWalk</td><td>28.3</td><td>34.7</td><td>38.1</td><td>42.0</td><td>45.6</td><td>50.7</td><td>40.4</td><td>53.8</td><td>59.4</td><td>65.4</td><td>69.9</td><td>74.2</td></tr><tr><td>LINE</td><td>28.0</td><td>34.7</td><td>38.0</td><td>43.1</td><td>48.5</td><td>54.6</td><td>49.4</td><td>62.6</td><td>63.4</td><td>71.1</td><td>74.0</td><td>76.5</td></tr><tr><td>G2G</td><td>45.1</td><td>56.4</td><td>60.3</td><td>63.1</td><td>65.7</td><td>68.2</td><td>54.5</td><td>68.1</td><td>70.9</td><td>73.8</td><td>75.8</td><td>77.0</td></tr><tr><td>DGI</td><td>46.1</td><td>59.2</td><td>64.1</td><td>67.6</td><td>68.7</td><td>72.3</td><td>55.3</td><td>70.9</td><td>72.6</td><td>76.4</td><td>77.9</td><td>78.7</td></tr><tr><td>GCN</td><td>36.4</td><td>50.3</td><td>57.5</td><td>63.2</td><td>68.8</td><td>72.2</td><td>42.4</td><td>61.6</td><td>68.4</td><td>75.1</td><td>80.2</td><td>83.5</td></tr><tr><td>GAT</td><td>32.8</td><td>48.6</td><td>54.9</td><td>60.8</td><td>68.2</td><td>71.5</td><td>41.8</td><td>61.7</td><td>71.1</td><td>76.0</td><td>79.6</td><td>83.4</td></tr><tr><td>MoNet</td><td>38.8</td><td>52.9</td><td>59.7</td><td>64.6</td><td>66.9</td><td>69.9</td><td>43.4</td><td>61.2</td><td>70.9</td><td>76.1</td><td>79.3</td><td>83.9</td></tr><tr><td>Co-training</td><td>36.7</td><td>49.0</td><td>55.0</td><td>60.7</td><td>65.9</td><td>70.0</td><td>53.1</td><td>65.7</td><td>70.2</td><td>73.8</td><td>78.7</td><td>82.5</td></tr><tr><td>Self-training</td><td>34.6</td><td>50.0</td><td>58.7</td><td>67.4</td><td>69.1</td><td>71.3</td><td>40.6</td><td>63.9</td><td>71.1</td><td>75.5</td><td>79.1</td><td>81.6</td></tr><tr><td>Union</td><td>37.2</td><td>50.8</td><td>55.9</td><td>64.4</td><td>67.5</td><td>70.6</td><td>50.1</td><td>67.3</td><td>72.5</td><td>76.2</td><td>79.8</td><td>82.4</td></tr><tr><td>Intersection</td><td>35.3</td><td>51.8</td><td>60.7</td><td>67.1</td><td>70.2</td><td>72.2</td><td>43.1</td><td>64.4</td><td>69.5</td><td>73.1</td><td>78.4</td><td>82.0</td></tr><tr><td>DSGCN</td><td>53.2</td><td>63.9</td><td>65.8</td><td>67.6</td><td>70.5</td><td>72.4</td><td>62.5</td><td>72.3</td><td>75.5</td><td>77.7</td><td>80.8</td><td>83.8</td></tr></table>
+
+Table 3: Summary of results in terms of mean classification accuracy(in percent) over 100 random splits in different tasks. GNN variants are excluded due to limited computation resources.   
+
+<table><tr><td></td><td colspan="6">Pubmed</td><td colspan="6">Cora-full</td></tr><tr><td># of Labels</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>LP</td><td>55.7 41.3</td><td>61.9 54.9</td><td>63.5 63.6</td><td>65.2 71.2</td><td>66.4 77.8</td><td>67.5 81.0</td><td>26.3 26.4</td><td>32.4 42.8</td><td>35.1 49.3</td><td>38.0 54.4</td><td>41.0 61.2</td><td>46.0 65.4</td></tr><tr><td>GCN</td><td></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> Co-training</td><td>55.1</td><td>64.7 62.7</td><td>69.0 67.2</td><td>73.5</td><td>77.9</td><td>80.5</td><td>28.3</td><td>38.1</td><td>42.8</td><td>48.5</td><td>53.8</td><td>62.2</td></tr><tr><td>Self-training</td><td>49.7</td><td>65.4</td><td>69.7</td><td>70.6 74.0</td><td>76.5 78.5</td><td>79.3 80.9</td><td>28.7 29.2</td><td>43.6 43.3</td><td>48.9 48.4</td><td>53.4 52.9</td><td>60.8 59.2</td><td>64.4 62.2</td></tr><tr><td>Union Intersection</td><td>55.1 52.7</td><td>63.4</td><td>67.8</td><td>70.6</td><td>75.9</td><td>79.0</td><td>26.8</td><td>37.7</td><td>44.4</td><td>51.5</td><td>58.4</td><td>62.1</td></tr><tr><td>DSGCN</td><td>55.8</td><td>67.1</td><td>70.2</td><td>74.7</td><td>77.8</td><td>81.0</td><td>30.9</td><td>45.6</td><td>51.3</td><td>57.5</td><td>61.4</td><td>64.8</td></tr></table>
+
+Comparison Between GNN Variants and Embedding Methods As unsupervised methods, G2G and DGI outperform all GNN variants in very few labels cases, e.g., 1 and 3 per class on both Cora and Citeseer. Observing that LP performs well in Cora-1 while other feature propagation methods not, we can naturally conclude that in dataset with graph structure, concentrating more on the unsupervised information (both strong manifold structure(Li et al., 2018) and feature patterns) will improve semi-supervised model compared to just utilizing supervised information, in the case of low label rate. When label rate goes higher, all GNN variants enjoy better accuracies compared to unsupervised models. Hence we empirically verify the strong generalization ability of GNNs when the supervised information is sufficient. Sun et al. (Sun et al., 2019) has demonstrated the limitation of GCN in few labels case, and here we find that these convolution based methods suffer from inefficient propagation of label information as well, which can be seen as the intrinsic drawbacks of semi-supervised graph convolution based methods.
+
+Comparison Between Self-training GCNs and All Other Models In all few-label tasks, selftraining strategies improve over GCN by a remarkable margin. Except for tasks with 50 labels per class, the best accuracy is always obtained by self-training GCN. Even in extreme one-label case, where unsupervised information is more vital, DSGCN outperforms G2G by a margin of $6 . 2 \%$ in Cora and $9 . 2 \%$ in Citeseer. We conclude that self-training strategy is capable of utilizing unsupervised information more effectively. Thus it significantly helps classification. Additionally, four naive selftraining GCNs implemented in (Li et al., 2018) are worse than GCN when label rate goes higher, e.g., Cora-50 and Cora-full-5, which manifests that inappropriate self-training strategies will sometimes degrade the performance of the base model. Hence there is a trade-off: capturing unsupervised signals, or learning supervised information well. However, DSGCN holds a good balance here. It doesn’t show much decrease compared to GCN even in the worst case task, Cora-full-50, where the accuracy only decreases by $0 . 6 \%$ ; in all other cases it is always better than GCN. This demonstrates that the dynamic self-training framework not only helps the original model to capture unsupervised information, but also retains the learning ability when there are enough labels.
+
+![](images/5612d4ef82c314a549957b6f901ddeb30cbef2a0a33782321d144bd0944db9e0.jpg)  
+Figure 1: Test accuracies in training process. Models with different threshold are denoted with different colors, which can be distinguished in legend. Specifically, threshold 1 represents that the model is equal to original GCN.
+
+Comparison of Self-training GCNs By applying a simpler and more general self-training strategy, DSGCN outperforms other self-training based GCNs with considerable margins in most cases. In Citeseer-1, the margin even reaches $1 4 . \bar { 1 \% }$ compared with the best strategy among Co-training, Selftraining, Union and Intersection. This empirically supports the advantage of DSGCN for tackling a wide range of classification tasks over conventional self-training methods.
+
+Effect of Threshold Here we discuss how the important hyper-parameter $\beta$ influence the performance of DSGCN. We train DSGCN with different threshold: 0.45, 0.6, 0.75, 0.9, 1.0 for 1000 epochs on dataset Cora and Citeseer for the same split with the same initialized weights. We conduct these experiments on tasks with different seed numbers, the results are presented in figure 1. As shown in figure 1, when labels are very few, DSGCN with a relatively lower threshold $\beta$ demonstrate a clear improvement in accuracy over the original GCN. Besides, GCN’s accuracy curve erratically fluctuates while the curve of DSGCN with a low threshold does not. Thus, we observe that the stability of the base model is also improved by wrapping it into the dynamic self-training framework. When more labels are provided, all models tend to be stable and a low threshold could harm the training process.
+
+# 6 CONCLUSION
+
+In this paper, we firstly introduce a novel self-training framework. This framework generalizes and simplifies prior work, providing customizable modules as extension for multi-stage self-training. Then we instantiate this framework based on GCN and empirically compare this model with a number of methods on different dataset splits. Result of experiments suggests that when labels are few, the proposed DSGCN not only outperform all previous models with noticeable margins in accuracy but also enjoy better stability in the training process. Overall, the Dynamic Self-training Framework is powerful for few-label tasks on graph data, and provides a novel perspective on self-training techniques.
+
+# REFERENCES
+
+James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016.
+
+Aleksandar Bojchevski and Stephan Günnemann. Deep gaussian embedding of graphs: Unsupervised inductive learning via ranking. International Conference on Learning Representations, 2018.
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. International Conference on Learning Representations, 2014.
+
+Eliav Buchnik and Edith Cohen. Bootstrapped graph diffusions: Exposing the power of nonlinearity. In Abstracts of the 2018 ACM International Conference on Measurement and Modeling of Computer Systems, pp. 8–10. ACM, 2018.
+
+Jie Chen, Tengfei Ma, and Cao Xiao. Fastgcn: fast learning with graph convolutional networks via importance sampling. International Conference on Learning Representations, 2018.
+
+Minmin Chen, Kilian Q Weinberger, and John Blitzer. Co-training for domain adaptation. In Advances in neural information processing systems, pp. 2456–2464, 2011.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016.
+
+Brett Drury, Luis Torgo, and Jose Joao Almeida. Guided self training for sentiment classification. In Proceedings of Workshop on Robust Unsupervised and Semisupervised Methods in Natural Language Processing, pp. 9–16, 2011.
+
+David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015.
+
+Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017.
+
+Marti Hearst. Noun homograph disambiguation using local context in large text corpora. Using Corpora, pp. 185–188, 1991.
+
+Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015.
+
+Zhongqiang Huang and Mary Harper. Self-training pcfg grammars with latent annotations across languages. In Proceedings of the 2009 conference on empirical methods in natural language processing: Volume 2-Volume 2, pp. 832–841. Association for Computational Linguistics, 2009.
+
+Zhongqiang Huang, Vladimir Eidelman, and Mary Harper. Improving a simple bigram hmm partof-speech tagger by latent annotation and self-training. In Proceedings of Human Language Technologies: The 2009 Annual Conference of the North American Chapter of the Association for Computational Linguistics, Companion Volume: Short Papers, pp. 213–216. Association for Computational Linguistics, 2009.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. International Conference on Learning Representations, 2017.
+
+Zornitsa Kozareva, Boyan Bonev, and Andres Montoyo. Self-training and co-training applied to spanish named entity recognition. In Mexican International conference on Artificial Intelligence, pp. 770–779. Springer, 2005.
+
+Dong-Hyun Lee. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on Challenges in Representation Learning, ICML, volume 3, pp. 2, 2013.
+
+Jurica Levatic, Michelangelo Ceci, Dragi Kocev, and Sašo Džeroski. Self-training for multi-target ´ regression with tree ensembles. Knowledge-Based Systems, 123:41–60, 2017.
+
+Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Qian Liu, Bingyang Liu, Dayong Wu, Yue Liu, and Xueqi Cheng. A self-learning template approach for recognizing named entities from web text. In Proceedings of the Sixth International Joint Conference on Natural Language Processing, pp. 1139–1143, 2013a.
+
+Zhiguang Liu, Xishuang Dong, Yi Guan, and Jinfeng Yang. Reserved self-training: A semi-supervised sentiment classification method for chinese microblogs. In Proceedings of the Sixth International Joint Conference on Natural Language Processing, pp. 455–462, 2013b.
+
+David McClosky, Eugene Charniak, and Mark Johnson. Effective self-training for parsing. In Proceedings of the main conference on human language technology conference of the North American Chapter of the Association of Computational Linguistics, pp. 152–159. Association for Computational Linguistics, 2006.
+
+David McClosky, Eugene Charniak, and Mark Johnson. When is self-training effective for parsing? In Proceedings of the 22nd International Conference on Computational Linguistics-Volume 1, pp. 561–568. Association for Computational Linguistics, 2008.
+
+Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proc. CVPR, volume 1, pp. 3, 2017.
+
+Kamal Nigam, Andrew Kachites McCallum, Sebastian Thrun, and Tom Mitchell. Text classification from labeled and unlabeled documents using em. Machine learning, 39(2-3):103–134, 2000.
+
+Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014.
+
+Yanjun Qi, Pavel Kuksa, Ronan Collobert, Kunihiko Sadamasa, Koray Kavukcuoglu, and Jason Weston. Semi-supervised sequence labeling with self-learned features. In 2009 Ninth IEEE International Conference on Data Mining, pp. 428–437. IEEE, 2009.
+
+Ellen Riloff, Rosie Jones, et al. Learning dictionaries for information extraction by multi-level bootstrapping. In AAAI/IAAI, pp. 474–479, 1999.
+
+Ellen Riloff, Janyce Wiebe, and Theresa Wilson. Learning subjective nouns using extraction pattern bootstrapping. In Proceedings of the seventh conference on Natural language learning at HLTNAACL 2003-Volume 4, pp. 25–32. Association for Computational Linguistics, 2003.
+
+Chuck Rosenberg, Martial Hebert, and Henry Schneiderman. Semi-supervised self-training of object detection models. WACV/MOTION, 2, 2005.
+
+Kenji Sagae. Self-training without reranking for parser domain adaptation and its impact on semantic role labeling. In Proceedings of the 2010 Workshop on Domain Adaptation for Natural Language Processing, pp. 37–44. Association for Computational Linguistics, 2010.
+
+H Scudder. Probability of error of some adaptive pattern-recognition machines. IEEE Transactions on Information Theory, 11(3):363–371, 1965.
+
+Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008.
+
+Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. CoRR, abs/1811.05868, 2018. URL http://arxiv.org/ abs/1811.05868.
+
+Ke Sun, Zhanxing Zhu, and Zhouchen Lin. Multi-stage self-supervised learning for graph convolutional networks. arXiv preprint arXiv:1902.11038, 2019.
+
+Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Large-scale information network embedding. In Proceedings of the 24th International Conference on World Wide Web, pp. 1067–1077, 2015.
+
+Vincent Van Asch and Walter Daelemans. Predicting the effectiveness of self-training: Application to sentiment classification. arXiv preprint arXiv:1601.03288, 2016.
+
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. International Conference on Learning Representations, 2018.
+
+Petar Velickovi ˇ c, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon ´ Hjelm. Deep graph infomax. International Conference on Learning Representations, 2019.
+
+Daixin Wang, Peng Cui, and Wenwu Zhu. Structural deep network embedding. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 1225–1234. ACM, 2016.
+
+Wen Wang, Zhongqiang Huang, and Mary Harper. Semi-supervised learning for part-of-speech tagging of mandarin transcribed speech. In 2007 IEEE International Conference on Acoustics, Speech and Signal Processing-ICASSP’07, volume 4, pp. IV–137. IEEE, 2007.
+
+Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In International Conference on Machine Learning, pp. 6861–6871, 2019.
+
+Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. International Conference on Machine Learning, 2018.
+
+David Yarowsky. Unsupervised word sense disambiguation rivaling supervised methods. In 33rd annual meeting of the association for computational linguistics, 1995.
+
+Yan Zhou, Murat Kantarcioglu, and Bhavani Thuraisingham. Self-training with selection-by-rejection. In 2012 IEEE 12th international conference on data mining, pp. 795–803. IEEE, 2012.
+
+Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International conference on Machine learning, pp. 912–919, 2003.
+
+# A APPENDIX: ADDITIONAL EXPERIMENTS
+
+We also test our self-training methods on other GNNs as well, e.g., SGC(Wu et al., 2019), GAT (Velickovic et al., 2018), and GraphSage (Hamilton et al., 2017). For the three GNN models, settings of hyper-parameters are the same as suggested in original papers. And our dynamic self-training framework share the same setting of hyper-parameter: one hidden layer with 32 units, dropout rate 0.7, Adam optimizer (Kingma & Ba, 2015), a $L _ { 2 }$ regularization with weight $5 ^ { - 4 }$ and set the threshold to 0.9. Clearly, our dynamic self-training framework achieves similar improvements on all the three base models. The numerical results are summarized in Table 4. We can see equipped with our DS framework, these models enjoys noticeable increase in performance.
+
+Table 4: Summary of results in terms of mean classification accuracy (in percent) over 50 random splits in different tasks(the results of GAT experiments are from Table 2).   
+
+<table><tr><td></td><td colspan="4">Citeseer</td><td colspan="4">Cora</td></tr><tr><td># ofLabels</td><td>5</td><td>10</td><td>20</td><td>50</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>SGC</td><td>55.5</td><td>63.7</td><td>69.0</td><td>72.6</td><td>63.5</td><td>72.5</td><td>75.9</td><td>78.9</td></tr><tr><td>DS-SGC</td><td>59.6</td><td>65.0</td><td>69.7</td><td>73.4</td><td>65.0</td><td>73.4</td><td>76.2</td><td>78.9</td></tr><tr><td>GAT DS-GAT</td><td>54.9</td><td>60.8</td><td>68.2</td><td>71.5</td><td>71.1</td><td>76.0</td><td>79.6</td><td>83.4</td></tr><tr><td></td><td>58.3</td><td>67.0</td><td>70.8</td><td>73.4</td><td>71.9</td><td>77.1</td><td>81.0</td><td>83.6</td></tr><tr><td>GraphSAGE</td><td>59.7</td><td>65.4</td><td>68.8</td><td>72.1</td><td>69.3</td><td>75.3</td><td>79.2</td><td>82.5</td></tr><tr><td>DS-GraphSAGE</td><td>60.6</td><td>66.3</td><td>69.5</td><td>72.6</td><td>72.5</td><td>78.4</td><td>81.0</td><td>84.0</td></tr></table>
+
+To evaluate the computation overhead introduced by dynamic self-training framework, we test the total training time for various models. Intuitively the computational cost will only slightly increase. The reason is that the computational cost of the original GCN model is dominated by previous layers, where the entire graph is included. So even if all nodes become pseudo labels, the size of the entire network is increased by at most a factor of 2, and the number of parameters remains the same. Therefore, the computational costs will increase by at most a small constant in theory. We have also verified this empirically. We record the training time of base models before and after applying our framework. In the experiments, the training size is 20 per class, the number of epoch is 200, and the time is the average time (in seconds) of 25 runs. The numerical results can be seen in Tabel 5.
+
+Table 5: Total training time for various models in seconds(s), implemented on PyG.   
+
+<table><tr><td></td><td>Citeseer</td><td>Cora</td></tr><tr><td>GCN</td><td>3.0</td><td>2.6</td></tr><tr><td>DSGCN</td><td>9.7</td><td>6.3</td></tr><tr><td>SGC</td><td>1.4</td><td>1.3</td></tr><tr><td>DS-SGC</td><td>7.1</td><td>7.4</td></tr><tr><td>GAT</td><td>5.2</td><td>4.7</td></tr><tr><td>DS-GAT</td><td>11.9</td><td>8.7</td></tr><tr><td>GraphSAGE</td><td>1.9</td><td>2.1</td></tr><tr><td>DS-GraphSAGE</td><td>8.7</td><td>8.5</td></tr></table>

parse/train/SJgCEpVtvr/SJgCEpVtvr_content_list.json

@@ -0,0 +1,1456 @@
+[
+    {
+        "type": "text",
+        "text": "DYNAMIC SELF-TRAINING FRAMEWORK FOR GRAPH CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph neural networks (GNN) such as GCN, GAT, MoNet have achieved stateof-the-art results on semi-supervised learning on graphs. However, when the number of labeled nodes is very small, the performances of GNNs downgrade dramatically. Self-training has proved to be effective for resolving this issue, however, the performance of self-trained GCN is still inferior to that of G2G and DGI for many settings. Moreover, additional model complexity make it more difficult to tune the hyper-parameters and do model selection. We argue that the power of self-training is still not fully explored for the node classification task. In this paper, we propose a unified end-to-end self-training framework called Dynamic Self-traning, which generalizes and simplifies prior work. A simple instantiation of the framework based on GCN is provided and empirical results show that our framework outperforms all previous methods including GNNs, embedding based method and self-trained GCNs by a noticeable margin. Moreover, compared with standard self-training, hyper-parameter tuning for our framework is easier. ",
+        "bbox": [
+            233,
+            266,
+            766,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            336,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graphs or networks can be used to model any interactions between entities such as social interactions (Facebook, Twitter), biological networks (protein-protein interaction), and citation networks. There has been an increasing research interest in deep learning on graph structured data, e.g., (Bruna et al., 2014; Defferrard et al., 2016; Monti et al., 2017; Kipf & Welling, 2017; Hamilton et al., 2017; Velickovic et al., 2018; Tang et al., 2015; Perozzi et al., 2014). ",
+        "bbox": [
+            174,
+            520,
+            825,
+            590
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semi-supervised node classification on graphs is a fundamental learning task with many applications. Classic methods rely on some underly diffusion process to propagate label information. Recently, network embedding approaches have demonstrate outstanding performance on node classification (Tang et al., 2015; Grover & Leskovec, 2016; Bojchevski & Günnemann, 2018). This approach first learns a lower-dimensional embedding for each node in an unsupervised manner, and then the embeddings are used to train a supervised classifier for node classification, e.g., logistic regression or multi-layer perceptron (MLP). Graph neural networks (GNN) are semi-supervised models and have achieved state-of-the-art performance on many benchmark data sets (Monti et al., 2017; Kipf & Welling, 2017; Velickovic et al., 2018). GNNs generalize convolution to graph structured data and typically have a clear advantage when the number of training examples is reasonably large. However, when there are very few labeled nodes, GNNs is outperformed by embedding based method (as shown by our experimental results), e.g., G2G from (Bojchevski & Günnemann, 2018) and DGI from (Velickovi ˇ c et al., 2019). ´ ",
+        "bbox": [
+            174,
+            597,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To overcome this limitation of GCNs (Kipf & Welling, 2017), Li et al. (Li et al., 2018) propose to apply self-training and co-training techniques (Scudder, 1965). The idea of these techniques is to augment the original training set by adding in some unlabeled examples together with their label predictions. Such “pseudo-label” information is either from the base model trained on the original training set (self-training) or another learning algorithm (co-training). The results from (Li et al., 2018) demonstrate the effectiveness of co-training and self-training. However, among the four variants implemented in (Li et al., 2018), there is not a single one that achieves the best performance across different settings; and from our experiments, G2G and DGI outperforms all the four variants when the number of labels from each class is less than 10. There are clear restrictions in prior self-training approaches. First, the pseudo-label set is incremental only, i.e., after an unlabeled example is added to the training set, it will never be deleted and its pseudo-label will never change even if its prediction and/or the corresponding margin has changed drastically. Secondly, all the pseudo-labels are considered equal, although they may have very different classification margins. Furthermore, it introduces extra hyper-parameters such as the number of unlabeled nodes to be added into the training set and the total number of self-training iterations. The performance gain is sensitive to such parameters and their optimal values may differ for different data sets and label rates (Buchnik & Cohen, 2018). ",
+        "bbox": [
+            174,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            200
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To fully understand and explore the power of self-training on the node classification task, we propose a novel self-training framework, named Dynamic Self-training, which is general, flexible, and easy to use. We provide a simple instantiation of the framework based on GCN (Kipf & Welling, 2017) and empirically show that it outperforms state-of-art methods including GNNs, self-trained GCN (Li et al., 2018), and embedding based methods. Our framework has the following distinguishing features compared with (Li et al., 2018; Buchnik & Cohen, 2018). ",
+        "bbox": [
+            174,
+            208,
+            825,
+            291
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. We augment the training set and recalculate the pseudo-labels after each epoch. So the number self-training iterations is the same as the number of epochs and the pseudo-label assigned to an unlabeled example may change during the training process.   \n2. In stead of inserting a fixed number of new pseudo-labels with highest margin in each iteration, we use a threshold-based rule, i.e., insert an unlabeled node if and only if its classification margin is above the threshold.   \n3. The pseudo-label set is dynamic. When the margin of an unlabeled node is above the threshold, we activate it by adding it to the loss function, but if the margin of this node becomes lower than the threshold in a later epoch, we will deactivate it.   \n4. We assign a (dynamic) personalized weight to each active pseudo-label proportional to its current classification margin. The total pseudo-label loss is thus the weighted sum of losses corresponds to all pseudo-labels. ",
+        "bbox": [
+            210,
+            303,
+            825,
+            482
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PRELIMINARIES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            501,
+            339,
+            517
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 GRAPH NOTATION AND PROBLEM DEFINITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            532,
+            537,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the problem, we are given an undirected graph with node attributes $G = ( V , E , X )$ , where $V$ is the vertex set, $E$ is the edge set. Here, $X$ is the feature matrix, the $i$ -th row of which, denoted as $x _ { i }$ , is the feature vector of node $i$ . We assume each node belongs to exactly one class and use $y _ { i }$ to denote the class label of the $i$ -th node. The aim is to design learning algorithms to predict the labels of all nodes based on the labels of a small set of training nodes provided in the beginning. We use $\\mathcal { N } _ { k } ( i )$ to denote the set of nodes whose distance to node $i$ is at most $k$ . $\\mathcal { L } \\subset V$ is the set of labeled nodes and $\\mathcal { U } = V \\setminus \\mathcal { L }$ is the set of unlabeled nodes. ",
+        "bbox": [
+            173,
+            558,
+            825,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            671,
+            478,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "GCN introduced in (Kipf & Welling, 2017) is a graph neural network model for semi-supervised classification. GCN learns the representations of each node by iteratively aggregating the embeddings of its neighbors. Specifically, GCN consists of $L > 0$ layers each with the same propagation rule defined as follows. In the $l$ -th layer, the hidden representations $H ^ { ( l - 1 ) }$ are averaged among one-hop neighbors as: ",
+        "bbox": [
+            173,
+            696,
+            825,
+            768
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2469868874f0d471ec5180aa513fb2d69247ee43db578310c363323cd634bd5c.jpg",
+        "text": "$$\nH ^ { ( l ) } = \\sigma ( \\tilde { D } ^ { - \\frac { 1 } { 2 } } \\tilde { A } \\tilde { D } ^ { - \\frac { 1 } { 2 } } H ^ { ( l - 1 ) } W ^ { ( l ) } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            767,
+            620,
+            787
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Here, ${ \\tilde { A } } = A + I _ { n }$ is the adjacency matrix of $G$ after adding self-loops ( $I _ { n }$ is the identity matrix), $\\tilde { D }$ is a diagonal matrix with $\\tilde { D _ { i i } } = \\dot { \\sum _ { j } { A _ { i j } } }$ , $W ^ { ( l ) }$ is a trainable weight matrix of the $l$ -th layer, and $\\sigma$ is a nonlinear activation function; $\\dot { H ^ { ( l ) } } \\in \\mathbb { R } ^ { n \\times d _ { l } }$ denotes hidden feature matrix of the $l$ -th layer and $H ^ { ( 0 ) } = X$ and $f _ { i } = H _ { i } ^ { ( L ) }$ represents the output of $i$ -th node. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            856
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We use $l ( y _ { i } , f _ { i } )$ to denote the classification loss of node $i$ , which is typically the cross entropy function. Thus, loss function used by GCN is of the form: ",
+        "bbox": [
+            173,
+            862,
+            823,
+            891
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/793de7af6e9c526347c3f4a31847b4b79110deb548ce854e410b461a8bd97201.jpg",
+        "text": "$$\nL = \\sum _ { i \\in \\mathcal { L } } l ( y _ { i } , f _ { i } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            893,
+            555,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For a $k$ -layer GCN, the receptive field of each training example is its order- $k$ neighborhood. When there are only few training samples, we need to increase the number of layers in order to cover most of the unlabeled nodes. However, deeper GCN will cause the problem of over-smoothing, i.e., critical features of the vertices may be smoothed through the iterative averaging process, which makes nodes from different class indistinguishable (Xu et al., 2018; Li et al., 2018). ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 SELF TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            190,
+            326,
+            204
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently (Li et al., 2018) apply self-training to overcome these limitations of GCNs. Self-training is a natural and general approach to semi-supervised learning, which is particularly well-motivated in the context of node classification (Buchnik & Cohen, 2018; Li et al., 2018). Assume we have a base model/algorithm for the learning problem, which takes as input a set of labeled examples and makes predictions for other examples. Typically, for each unlabeled node, the base algorithm will also return an associated margin or confidence score. The self-training framework trains and applies the base model in rounds, where at the end of each round, the highest-confidence predictions are converted to become new labeled examples in the next round of training and prediction. Thus, the receptive fields of all the labeled nodes increases and will eventually cover the entire graph, which resolve the issue of GCNs without adding more layers. ",
+        "bbox": [
+            173,
+            215,
+            825,
+            354
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 OUR METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            375,
+            325,
+            391
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 A GENERALIZED SELF-TRAINING FRAMEWORK ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            406,
+            545,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1: Dynamic Self-training Framework ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            493,
+            455
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1 Generate initial parameter $\\theta ^ { 0 }$ for model $f ( \\cdot , \\cdot )$ , and the initial confidence score vector $S _ { V }$ .   \n2 for each epoch $t = 1 , 2 , . . . , T$ do   \n3 Compute prediction $f _ { V } \\gets f ( G , \\theta ^ { t - 1 } )$   \n4 Update confidence score $S _ { V }  { \\mathcal { U C } } ( f _ { V } )$ .   \n5 Update model parameter by confidence score. $\\theta ^ { t } \\gets \\mathcal { U P } ( f _ { V } , S _ { V } , f )$   \n6 if stopping criteria is met then   \n7 Break   \n8 end   \n9 end ",
+        "bbox": [
+            160,
+            459,
+            767,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Sun et al. (Sun et al., 2019) proposed Multi-stage Training Framework as generalization for selftraining method in (Li et al., 2018). Inspired by this, we propose a more generalized end-to-end self-training framework named Dynamic Self-training Framework shown in algorithm 1. Instead of operating on data split, we maintain a confidence score in each iteration. There is no specified training stages here, but we update the confidence value for each unlabeled node after every epoch. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Consider the original model $f ( \\cdot , \\cdot )$ as a forward predicting function with backward trainable parameters. The graph data $G$ and the trainable parameters $\\theta ^ { t }$ is the input of this function, and the output of this model is collected into $f _ { V } \\in \\mathbb { R } ^ { n \\times C }$ , where $f _ { v }$ denotes the output vector (before assigned with label) of node $v \\in V$ , and $C = d _ { L }$ is the number of classes. Then we construct the confidence score vector $S _ { V } \\in \\mathbb { R } ^ { n }$ from the model output $f _ { v }$ using a function $\\mathcal { U } \\mathcal { C }$ , which can be instantiated in many forms. For example, Algorithm 2 illustrates how standard multi-stage self-training GCN implement this part. Finally we update the model parameters using a specified algorithm such as gradient descent, where the confidence score vector plays a role. The confidence score participates in the parameter updating process in an end-to-end manner. An example of this part can be seen in section 3.3. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 PSEUDO LABEL METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            845,
+            393,
+            859
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Define the pseudo label $\\tilde { y } _ { i } \\in \\mathbb { R } ^ { d _ { L } }$ of $i$ -th node which satisfies : ",
+        "bbox": [
+            173,
+            871,
+            584,
+            887
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5692247967a662c336926481c69f313cb61e88f5a3aad85a2a20bccd4a7ce465.jpg",
+        "text": "$$\n\\tilde { y } _ { i j } = \\left\\{ \\begin{array} { l l } { 1 } & { \\mathrm { i f ~ } j = \\arg \\operatorname* { m a x } _ { j ^ { \\prime } } f _ { i j ^ { \\prime } } } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            892,
+            606,
+            928
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2: Update confidence score for Multi-stage Self-training GCN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            107,
+            665,
+            122
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/4bef78dfe6b47e6e532707d381ad27c645a614880740e87d2fd66092fd8576c4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\">if the stage is currently switched then</td></tr><tr><td>2</td><td>for each class k do</td></tr><tr><td>3</td><td>Find the top m vertices v in fv and v ∈U</td></tr><tr><td>4</td><td>Change the value of v in Sv to 1</td></tr><tr><td>5</td><td>end</td></tr><tr><td>6</td><td>return Sv</td></tr><tr><td colspan=\"2\">7 end</td></tr></table>",
+        "bbox": [
+            158,
+            125,
+            503,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(Lee, 2013) introduced a pseudo label version of semi-supervised losses: ",
+        "bbox": [
+            174,
+            256,
+            650,
+            270
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/776d47f5710e97157c358d58a16208a8bfde6af4b18e78b89960d72c2652aa9c.jpg",
+        "text": "$$\nL = \\sum _ { i \\in \\mathcal { L } } l ( y _ { i } , f _ { i } ) + \\lambda \\sum _ { i \\in \\mathcal { U } } l ( \\tilde { y } _ { i } , f _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            271,
+            612,
+            305
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\begin{array} { r } { \\lambda = \\frac { n } { n ^ { \\prime } } \\gamma } \\end{array}$ , $n = | \\mathcal { L } |$ , $n ^ { \\prime } = | \\boldsymbol { \\mathcal { U } } |$ , $\\gamma \\in \\mathbb R$ is a hyper-parameter and the additive term $\\textstyle \\sum _ { i \\in { \\mathcal { U } } } l ( { \\tilde { y } } _ { i } , f _ { i } )$ is the pseudo label loss. Here, $\\lambda$ measures how much the pseudo label term influence the training process. This is equivalent to Entropy Regularization for classification problems (Lee, 2013). ",
+        "bbox": [
+            174,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 SOFT LABEL CONFIDENCE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            364,
+            400,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In standard multi-stage self-training methods, a node just has two states: in the training set or not, which corresponds to binary-valued confidences $\\{ 0 , 1 \\}$ ; and in most cases, if a node is added in training set, it will be kept there. This simple setting hinders learning in some cases. For instance, if the classifier puts a wrongly labeled node into the training set, which is of high possibility in preliminary training epochs, it will persistently learn wrong knowledge from this node. Worse still, another wrongly adding is more possible. This negative feedback loop may contribute to a extremely poor classifier. Moreover, original labeled nodes and added nodes in the training are treated equally, which is too restricted and may harm the learning; explicitly distinguishing them in the training process could be beneficial. To resolve these problems, we introduce a mechanism named Soft Label Confidence as the confidence updating component in algorithm 1, which computes a personalized confidence value for each node, and the training set is dynamically changing except the ground truth labels. Based on the pseudo label loss (4), we propose the loss wrapped by soft label confidence: ",
+        "bbox": [
+            173,
+            390,
+            826,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/df02e8a3d9407b9e19928526f6ff4128b81fcc8c8166838f28c9219bdd035490.jpg",
+        "text": "$$\nL = \\sum _ { i \\in \\mathcal { L } } l ( y _ { i } , f _ { i } ) + \\lambda \\sum _ { i \\in \\mathcal { U } } \\alpha ( f _ { i } ) l ( \\tilde { y } _ { i } , f _ { i } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            559,
+            632,
+            593
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $\\alpha$ is a function mapping from $\\mathbb { R } ^ { d _ { L } }$ to $\\mathbb { R }$ , defined as confidence function. While there are other possible choices for $\\alpha$ , in our method we adopt a threshold based function: ",
+        "bbox": [
+            174,
+            595,
+            823,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c33e2d3418e781dfb7374a4177decc9bfb36e0081eded182aaeb29ef84d38de2.jpg",
+        "text": "$$\n\\alpha ( f _ { i } ) = \\frac { 1 } { n _ { c ^ { i } } ^ { \\prime } } \\mathrm { m a x } ( \\mathrm { R e L U } ( f _ { i } - \\beta \\cdot { \\bf 1 } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            626,
+            622,
+            660
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here $\\beta \\in ( 0 , 1 )$ is a hyper-parameter as threshold, $n _ { c ^ { i } } ^ { \\prime }$ denotes the number of nodes whose pseudo label belongs to class $c ^ { i }$ , $c ^ { i }$ is the class which $i$ -th node’s pseudo label belongs to, and 1 is the all 1 vector. We introduce $n _ { c ^ { i } } ^ { \\prime }$ here to balance the categories of pseudo labels, because pseudo labels could be initially extremely unbalanced and lead to a poor classifier in practice. ",
+        "bbox": [
+            173,
+            660,
+            825,
+            719
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Although $\\alpha ( f _ { i } )$ depends on $f _ { i }$ , and thus a function of network’s weights, we will block the flow of gradient through $\\alpha ( f _ { i } )$ for the following reasons: Firstly, confidence function is non-differentiable in most cases. Secondly, if we allow the gradient to flow through $\\alpha ( f _ { i } )$ , the optimizer may tend to find a solution that satisfies $\\operatorname* { m a x } ( f _ { i } ) < \\beta , \\mathsf { \\bar { \\forall } } i \\in V$ , since for such a solution, $\\overset { \\vartriangle } { \\alpha { \\left( f _ { i } \\right) } } = 0$ for all $i$ and the pseudo label loss is zero, which does no good to self-supervised learning. So we use the following way to compute the gradient: ",
+        "bbox": [
+            173,
+            726,
+            825,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/16f9d3244629c0bdb8796e5f2ff0eb8feb2af41def0202e0faeba257b3cbb0c1.jpg",
+        "text": "$$\n\\frac { \\partial L } { \\partial W _ { s , t } ^ { l } } = \\sum _ { i \\in \\mathcal { L } } \\frac { \\partial l ( y _ { i } , f _ { i } ) } { \\partial W _ { s , t } ^ { l } } + \\lambda \\sum _ { i \\in \\mathcal { U } } \\alpha ( f _ { i } ) \\frac { \\partial l ( \\tilde { y } _ { i } , f _ { i } ) } { \\partial W _ { s , t } ^ { l } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            810,
+            660,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            346,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Graph Convolutional Network The work of GNNs seeks generalizations of the convolution operator to graph structured data. One way to do this is to apply convolution in the spectral domain, where the eigenvectors of the graph Laplacian are considered as the Fourier basis (Bruna et al., 2014; Henaff et al., 2015; Defferrard et al., 2016; Kipf & Welling, 2017). Such spectral methods learns hidden layer representations that encode both graph structure and node features simultaneously. Kipf and Welling (Kipf & Welling, 2017) simplify previous spectral techniques by restricting the propagation to a 1-hop neighborhood in each layer. (Chen et al., 2018) propose fast GCNs, which improves the training speed of the original GCN. GAT of (Velickovic et al., 2018) allows for assigning different importances to nodes of the same neighborhood via attention mechanisms. (Xu et al., 2018) introduce JK networks, which adjust the influence radii of each node adaptively. Another direction that generalizes convolutions to graph structured data, namely non-spectral approaches, define convolutions directly in the spatial domain (Duvenaud et al., 2015; Atwood & Towsley, 2016; Monti et al., 2017). Such methods are easier to be adapted to do inductive learning (Hamilton et al., 2017; Velickovic et al., 2018; Bojchevski & Günnemann, 2018). However, few-shot learning remains a challenge for this class of methods. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Label Propagation Unlike GNNs, which propagate node representations, the classic Label Propagation (LP) method (Zhu et al., 2003) iteratively propagates (soft) labels. More specifically, in each iteration, each unlabeled node obtains a new soft label that is the aggregation of the soft labels from the previous iteration of its neighbors. The key to LP is to design an effective propagation rule; for some propagation rules, the algorithm may not converge and/or the accuracy may not improve over iterations. Thus, one often needs to specify a stopping criteria and a validation set for model selection. LP can also be used as the base algorithm in the self-training framework. ",
+        "bbox": [
+            174,
+            304,
+            826,
+            402
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Self-training Self-training is a natural and general approach to semi-supervised learning (Scudder, 1965) and has been widely used in the NLP literature. Self-training is used by (Yarowsky, 1995; Hearst, 1991) for word sense disambiguation. (Riloff et al., 1999) used self-training in the form of bootstrapping for information extraction and later for learning subjective nouns. (Riloff et al., 2003) with (Nigam et al., 2000) using EM for text classification. Self-training has been used for object recognition (Rosenberg et al., 2005; Zhou et al., 2012). (McClosky et al., 2006; 2008; Huang & Harper, 2009; Sagae, 2010) shows how effective can self-training be in parsing. (Wang et al., 2007; Huang et al., 2009; Qi et al., 2009) introduce self-training techniques to part of speech tagging, and (Kozareva et al., 2005; Liu et al., 2013a) adopt self-training in named entity recognition. (Van Asch & Daelemans, 2016; Drury et al., 2011; Liu et al., 2013b) used self-training in sentiment classification. Recently, self-training has also been successfully applied on node classification. Li et al. (Li et al., 2018) study self-training GCNs; Buchnik and Cohen (Buchnik & Cohen, 2018) mainly consider the effect self-training for diffusion-based techniques. In pseudo-label method of (Lee, 2013), for unlabeled data, their pseudo-labels are recalculated every weights update. However, they don’t assign weight to each unlabeled data. ",
+        "bbox": [
+            174,
+            424,
+            826,
+            631
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As for the self-training algorithm itself, (Chen et al., 2011) shows that selecting highly confident instances with a pre-defined threshold may not perform well. (McClosky et al., 2006) produce a ranked list of n-best predicted parses and selected the best one. (Rosenberg et al., 2005) shows that a training data selection metric that is defined independently of the detector greatly outperforms a selection metric based on the detection confidence generated by the detector. (Zhou et al., 2012) suggests that selecting more informative unlabelled data using a guided search algorithm can significantly improve performance over standard self-training framework. Most recently, (Levatic et al., 2017) proposed ´ proposed an algorithm to automatically select appropriate threshold. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            750
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Network Embedding Node classification is also one of the main applications of network embedding methods, which learns a lower-dimensional representation for each node in an unsupervised manner, followed by a supervised classifier layer for node classification (Perozzi et al., 2014; Tang et al., 2015; Grover & Leskovec, 2016; Wang et al., 2016; Bojchevski & Günnemann, 2018). A recent work of (Bojchevski & Günnemann, 2018) proposes Graph2Gauss. This method embeds each node as a Gaussian distribution according to a novel ranking similarity based on the shortest path distances between nodes. A distribution embedding naturally captures the uncertainty about the representation. DGI (Velickovi ˇ c et al., 2019) is an embedding method based on GCNs, the unsupervised objective of ´ which is to maximize mutual information. The work of Embedding approaches achieve competitive performance in node classification tasks, while the learned representations also prove to be extremely useful for other downstream applications. ",
+        "bbox": [
+            174,
+            770,
+            826,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            315,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            279,
+            148
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We conduct the evaluation on four benchmark citation datasets: Cora, Citeseer, Pubmed (Sen et al., 2008), and Core-full (Bojchevski & Günnemann, 2018). Each of these four datasets is undirected graph with node feature. Each node is a document and the edges denote the citation relationship; the feature of a node is the bag-of-words representation of the document. The number of layers in GCN is two by default, and thus the receptive field of each labeled node is its order-2 neighborhood. We measure the fraction of nodes which is covered by the 2-hop neighbors of all labeled nodes, i.e., $| \\cup _ { s \\in \\mathcal { S } } \\mathcal { N } _ { 2 } ( s ) | / | V |$ , where $s$ is the set of labeled nodes randomly sampled from $V$ . Here we report the 2-hop coverage ratio on the four datasets when the label rates are $1 \\%$ and $0 . 5 \\%$ respectively. We summarize the information of datasets in Table 1. ",
+        "bbox": [
+            174,
+            160,
+            826,
+            284
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/310a771f90177e9c3e08a8b93448b61b7432f8729f98ed159147ec887101c173.jpg",
+        "table_caption": [
+            "Table 1: Summary of datasets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Cora</td><td>Citeseer</td><td>Pubmed</td><td>Cora-full</td></tr><tr><td># of Nodes</td><td>2708</td><td>3327</td><td>19717</td><td>18703</td></tr><tr><td>#of Edges</td><td>5429</td><td>4732</td><td>44338</td><td>81124</td></tr><tr><td>#of Features</td><td>1433</td><td>3703</td><td>500</td><td>8710</td></tr><tr><td># of Classes</td><td>7</td><td>6</td><td>3</td><td>67</td></tr><tr><td>Coverage(0.5%)</td><td>14.78%</td><td>6.64%</td><td>21.58%</td><td>27.19%</td></tr><tr><td>Coverage(1%)</td><td>24.78%</td><td>12.14%</td><td>34.60%</td><td>47.42%</td></tr></table>",
+        "bbox": [
+            303,
+            324,
+            694,
+            425
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            463,
+            382,
+            478
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate models on semi-supervised node classification tasks with varying label rates. Instead of evaluating on a fixed data split as in (Kipf & Welling, 2017; Velickovic et al., 2018), we mainly consider random splits as (Li et al., 2018) does. In detail, for a given label rate, we randomly generate 100 different splits on each dataset. In each split, there is a labeled set with prespecified size for training, and in this set each class contains the same number of labeled nodes. As in (Li et al., 2018), we don’t use a validation set, and all the remaining nodes will be used for testing. For simplicity, we will refer to a task in the form of dataset-l, where $l$ is the number of labeled nodes per class. For example, Cora-1 denotes the classification task on dataset Cora with one seed per class. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            602
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            617,
+            405,
+            632
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For all the models(Perozzi et al., 2014; Tang et al., 2015; Grover & Leskovec, 2016; Wang et al., 2016; Bojchevski & Günnemann, 2018; Velickovic et al., 2018; Monti et al., 2017) except for GCN based methods, settings of hyper-parameters are the same as suggested in original papers. All GCN based methods including GCN, Self-training GCN, Co-training GCN, Intersection GCN, Union GCN, and DSGCN share the same setting of hyper-parameter following (Shchur et al., 2018): one hidden layer with 64 units, dropout rate 0.8, Adam optimizer (Kingma & Ba, 2015) with learning rate $1 0 ^ { - 2 }$ , a $L _ { 2 }$ regularization with weight $1 0 ^ { - 3 }$ . We train other GCN based methods for a fixed epochs of 200, while DSGCN is trained for 600 epochs in few-label tasks such as 1, 3, 5, 10 tasks. Because 20 or 50 labels per class implies ample supervised information, we train DSGCN for 200 epochs in these tasks. The four variants of (Li et al., 2018): Self-training GCN, Co-training GCN, Intersection GCN and Union GCN follow original self-training settings in (Li et al., 2018). For DSGCN, we use a threshold of 0.6 when the number of labels per class is below 3, and set the threshold to 0.75 for label rate above 3 but below 10. Otherwise, the threshold is 0.9 by default. ",
+        "bbox": [
+            173,
+            643,
+            826,
+            824
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.4 RESULT ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            346,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The numerical results are summarized in Table 2 and Table 3. The highest accuracy in each column is highlighted in bold and the top 3 are underlined. We group all models into three categories: GNN variants(GCN, GAT, MoNet), unsupervised embedding methods (DeepWalk, DGI, LINE, G2G) and GCN with self-training (Co-training, Self-training, Union and Intersection, DSGCN). ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/b7ce80ad2493113113e1f849d3309ddd2dd5874c6e3548eeb351abcb20ec73be.jpg",
+        "table_caption": [
+            "Table 2: Summary of results in terms of mean classification accuracy (in percent) over 100 random splits in different tasks. Unsupervised approaches first learn a lower-dimensional embedding for each node in an unsupervised manner, and then the embeddings are used to train a supervised classifier for node classification. Here we use logistic regression as the classifier for unsupervised embeddings. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"6\">Citeseer</td><td colspan=\"6\">Cora</td></tr><tr><td># of Labels</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>LP</td><td>30.1</td><td>37.0</td><td>39.3</td><td>41.9</td><td>44.8</td><td>49.5</td><td>51.5</td><td>60.5</td><td>62.5</td><td>64.2</td><td>67.3</td><td>71.7</td></tr><tr><td>DeepWalk</td><td>28.3</td><td>34.7</td><td>38.1</td><td>42.0</td><td>45.6</td><td>50.7</td><td>40.4</td><td>53.8</td><td>59.4</td><td>65.4</td><td>69.9</td><td>74.2</td></tr><tr><td>LINE</td><td>28.0</td><td>34.7</td><td>38.0</td><td>43.1</td><td>48.5</td><td>54.6</td><td>49.4</td><td>62.6</td><td>63.4</td><td>71.1</td><td>74.0</td><td>76.5</td></tr><tr><td>G2G</td><td>45.1</td><td>56.4</td><td>60.3</td><td>63.1</td><td>65.7</td><td>68.2</td><td>54.5</td><td>68.1</td><td>70.9</td><td>73.8</td><td>75.8</td><td>77.0</td></tr><tr><td>DGI</td><td>46.1</td><td>59.2</td><td>64.1</td><td>67.6</td><td>68.7</td><td>72.3</td><td>55.3</td><td>70.9</td><td>72.6</td><td>76.4</td><td>77.9</td><td>78.7</td></tr><tr><td>GCN</td><td>36.4</td><td>50.3</td><td>57.5</td><td>63.2</td><td>68.8</td><td>72.2</td><td>42.4</td><td>61.6</td><td>68.4</td><td>75.1</td><td>80.2</td><td>83.5</td></tr><tr><td>GAT</td><td>32.8</td><td>48.6</td><td>54.9</td><td>60.8</td><td>68.2</td><td>71.5</td><td>41.8</td><td>61.7</td><td>71.1</td><td>76.0</td><td>79.6</td><td>83.4</td></tr><tr><td>MoNet</td><td>38.8</td><td>52.9</td><td>59.7</td><td>64.6</td><td>66.9</td><td>69.9</td><td>43.4</td><td>61.2</td><td>70.9</td><td>76.1</td><td>79.3</td><td>83.9</td></tr><tr><td>Co-training</td><td>36.7</td><td>49.0</td><td>55.0</td><td>60.7</td><td>65.9</td><td>70.0</td><td>53.1</td><td>65.7</td><td>70.2</td><td>73.8</td><td>78.7</td><td>82.5</td></tr><tr><td>Self-training</td><td>34.6</td><td>50.0</td><td>58.7</td><td>67.4</td><td>69.1</td><td>71.3</td><td>40.6</td><td>63.9</td><td>71.1</td><td>75.5</td><td>79.1</td><td>81.6</td></tr><tr><td>Union</td><td>37.2</td><td>50.8</td><td>55.9</td><td>64.4</td><td>67.5</td><td>70.6</td><td>50.1</td><td>67.3</td><td>72.5</td><td>76.2</td><td>79.8</td><td>82.4</td></tr><tr><td>Intersection</td><td>35.3</td><td>51.8</td><td>60.7</td><td>67.1</td><td>70.2</td><td>72.2</td><td>43.1</td><td>64.4</td><td>69.5</td><td>73.1</td><td>78.4</td><td>82.0</td></tr><tr><td>DSGCN</td><td>53.2</td><td>63.9</td><td>65.8</td><td>67.6</td><td>70.5</td><td>72.4</td><td>62.5</td><td>72.3</td><td>75.5</td><td>77.7</td><td>80.8</td><td>83.8</td></tr></table>",
+        "bbox": [
+            173,
+            167,
+            820,
+            380
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/08e6d2d02389e5a5d2ff4249bdb46a1e7e95efc9cb195ea623cf0b622a531080.jpg",
+        "table_caption": [
+            "Table 3: Summary of results in terms of mean classification accuracy(in percent) over 100 random splits in different tasks. GNN variants are excluded due to limited computation resources. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"6\">Pubmed</td><td colspan=\"6\">Cora-full</td></tr><tr><td># of Labels</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td><td>1</td><td>3</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>LP</td><td>55.7 41.3</td><td>61.9 54.9</td><td>63.5 63.6</td><td>65.2 71.2</td><td>66.4 77.8</td><td>67.5 81.0</td><td>26.3 26.4</td><td>32.4 42.8</td><td>35.1 49.3</td><td>38.0 54.4</td><td>41.0 61.2</td><td>46.0 65.4</td></tr><tr><td>GCN</td><td></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> Co-training</td><td>55.1</td><td>64.7 62.7</td><td>69.0 67.2</td><td>73.5</td><td>77.9</td><td>80.5</td><td>28.3</td><td>38.1</td><td>42.8</td><td>48.5</td><td>53.8</td><td>62.2</td></tr><tr><td>Self-training</td><td>49.7</td><td>65.4</td><td>69.7</td><td>70.6 74.0</td><td>76.5 78.5</td><td>79.3 80.9</td><td>28.7 29.2</td><td>43.6 43.3</td><td>48.9 48.4</td><td>53.4 52.9</td><td>60.8 59.2</td><td>64.4 62.2</td></tr><tr><td>Union Intersection</td><td>55.1 52.7</td><td>63.4</td><td>67.8</td><td>70.6</td><td>75.9</td><td>79.0</td><td>26.8</td><td>37.7</td><td>44.4</td><td>51.5</td><td>58.4</td><td>62.1</td></tr><tr><td>DSGCN</td><td>55.8</td><td>67.1</td><td>70.2</td><td>74.7</td><td>77.8</td><td>81.0</td><td>30.9</td><td>45.6</td><td>51.3</td><td>57.5</td><td>61.4</td><td>64.8</td></tr></table>",
+        "bbox": [
+            173,
+            429,
+            818,
+            565
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison Between GNN Variants and Embedding Methods As unsupervised methods, G2G and DGI outperform all GNN variants in very few labels cases, e.g., 1 and 3 per class on both Cora and Citeseer. Observing that LP performs well in Cora-1 while other feature propagation methods not, we can naturally conclude that in dataset with graph structure, concentrating more on the unsupervised information (both strong manifold structure(Li et al., 2018) and feature patterns) will improve semi-supervised model compared to just utilizing supervised information, in the case of low label rate. When label rate goes higher, all GNN variants enjoy better accuracies compared to unsupervised models. Hence we empirically verify the strong generalization ability of GNNs when the supervised information is sufficient. Sun et al. (Sun et al., 2019) has demonstrated the limitation of GCN in few labels case, and here we find that these convolution based methods suffer from inefficient propagation of label information as well, which can be seen as the intrinsic drawbacks of semi-supervised graph convolution based methods. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison Between Self-training GCNs and All Other Models In all few-label tasks, selftraining strategies improve over GCN by a remarkable margin. Except for tasks with 50 labels per class, the best accuracy is always obtained by self-training GCN. Even in extreme one-label case, where unsupervised information is more vital, DSGCN outperforms G2G by a margin of $6 . 2 \\%$ in Cora and $9 . 2 \\%$ in Citeseer. We conclude that self-training strategy is capable of utilizing unsupervised information more effectively. Thus it significantly helps classification. Additionally, four naive selftraining GCNs implemented in (Li et al., 2018) are worse than GCN when label rate goes higher, e.g., Cora-50 and Cora-full-5, which manifests that inappropriate self-training strategies will sometimes degrade the performance of the base model. Hence there is a trade-off: capturing unsupervised signals, or learning supervised information well. However, DSGCN holds a good balance here. It doesn’t show much decrease compared to GCN even in the worst case task, Cora-full-50, where the accuracy only decreases by $0 . 6 \\%$ ; in all other cases it is always better than GCN. This demonstrates that the dynamic self-training framework not only helps the original model to capture unsupervised information, but also retains the learning ability when there are enough labels. ",
+        "bbox": [
+            174,
+            770,
+            826,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/5612d4ef82c314a549957b6f901ddeb30cbef2a0a33782321d144bd0944db9e0.jpg",
+        "image_caption": [
+            "Figure 1: Test accuracies in training process. Models with different threshold are denoted with different colors, which can be distinguished in legend. Specifically, threshold 1 represents that the model is equal to original GCN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            99,
+            820,
+            324
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            406,
+            825,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Comparison of Self-training GCNs By applying a simpler and more general self-training strategy, DSGCN outperforms other self-training based GCNs with considerable margins in most cases. In Citeseer-1, the margin even reaches $1 4 . \\bar { 1 \\% }$ compared with the best strategy among Co-training, Selftraining, Union and Intersection. This empirically supports the advantage of DSGCN for tackling a wide range of classification tasks over conventional self-training methods. ",
+        "bbox": [
+            174,
+            464,
+            825,
+            534
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Effect of Threshold Here we discuss how the important hyper-parameter $\\beta$ influence the performance of DSGCN. We train DSGCN with different threshold: 0.45, 0.6, 0.75, 0.9, 1.0 for 1000 epochs on dataset Cora and Citeseer for the same split with the same initialized weights. We conduct these experiments on tasks with different seed numbers, the results are presented in figure 1. As shown in figure 1, when labels are very few, DSGCN with a relatively lower threshold $\\beta$ demonstrate a clear improvement in accuracy over the original GCN. Besides, GCN’s accuracy curve erratically fluctuates while the curve of DSGCN with a low threshold does not. Thus, we observe that the stability of the base model is also improved by wrapping it into the dynamic self-training framework. When more labels are provided, all models tend to be stable and a low threshold could harm the training process. ",
+        "bbox": [
+            174,
+            549,
+            825,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            708,
+            318,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we firstly introduce a novel self-training framework. This framework generalizes and simplifies prior work, providing customizable modules as extension for multi-stage self-training. Then we instantiate this framework based on GCN and empirically compare this model with a number of methods on different dataset splits. Result of experiments suggests that when labels are few, the proposed DSGCN not only outperform all previous models with noticeable margins in accuracy but also enjoy better stability in the training process. Overall, the Dynamic Self-training Framework is powerful for few-label tasks on graph data, and provides a novel perspective on self-training techniques. ",
+        "bbox": [
+            174,
+            739,
+            825,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            872,
+            285,
+            887
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "James Atwood and Don Towsley. Diffusion-convolutional neural networks. In Advances in Neural Information Processing Systems, pp. 1993–2001, 2016. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Aleksandar Bojchevski and Stephan Günnemann. Deep gaussian embedding of graphs: Unsupervised inductive learning via ranking. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. International Conference on Learning Representations, 2014. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eliav Buchnik and Edith Cohen. Bootstrapped graph diffusions: Exposing the power of nonlinearity. In Abstracts of the 2018 ACM International Conference on Measurement and Modeling of Computer Systems, pp. 8–10. ACM, 2018. ",
+        "bbox": [
+            178,
+            178,
+            825,
+            222
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jie Chen, Tengfei Ma, and Cao Xiao. Fastgcn: fast learning with graph convolutional networks via importance sampling. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            171,
+            229,
+            825,
+            258
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Minmin Chen, Kilian Q Weinberger, and John Blitzer. Co-training for domain adaptation. In Advances in neural information processing systems, pp. 2456–2464, 2011. ",
+        "bbox": [
+            171,
+            267,
+            825,
+            297
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In Advances in Neural Information Processing Systems, pp. 3844–3852, 2016. ",
+        "bbox": [
+            173,
+            304,
+            825,
+            348
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Brett Drury, Luis Torgo, and Jose Joao Almeida. Guided self training for sentiment classification. In Proceedings of Workshop on Robust Unsupervised and Semisupervised Methods in Natural Language Processing, pp. 9–16, 2011. ",
+        "bbox": [
+            173,
+            356,
+            826,
+            400
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David K Duvenaud, Dougal Maclaurin, Jorge Iparraguirre, Rafael Bombarell, Timothy Hirzel, Alán Aspuru-Guzik, and Ryan P Adams. Convolutional networks on graphs for learning molecular fingerprints. In Advances in neural information processing systems, pp. 2224–2232, 2015. ",
+        "bbox": [
+            174,
+            409,
+            826,
+            452
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aditya Grover and Jure Leskovec. node2vec: Scalable feature learning for networks. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 855–864. ACM, 2016. ",
+        "bbox": [
+            174,
+            459,
+            826,
+            502
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017. ",
+        "bbox": [
+            173,
+            511,
+            823,
+            541
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marti Hearst. Noun homograph disambiguation using local context in large text corpora. Using Corpora, pp. 185–188, 1991. ",
+        "bbox": [
+            173,
+            549,
+            823,
+            577
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Mikael Henaff, Joan Bruna, and Yann LeCun. Deep convolutional networks on graph-structured data. arXiv preprint arXiv:1506.05163, 2015. ",
+        "bbox": [
+            173,
+            587,
+            825,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhongqiang Huang and Mary Harper. Self-training pcfg grammars with latent annotations across languages. In Proceedings of the 2009 conference on empirical methods in natural language processing: Volume 2-Volume 2, pp. 832–841. Association for Computational Linguistics, 2009. ",
+        "bbox": [
+            173,
+            623,
+            826,
+            666
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhongqiang Huang, Vladimir Eidelman, and Mary Harper. Improving a simple bigram hmm partof-speech tagger by latent annotation and self-training. In Proceedings of Human Language Technologies: The 2009 Annual Conference of the North American Chapter of the Association for Computational Linguistics, Companion Volume: Short Papers, pp. 213–216. Association for Computational Linguistics, 2009. ",
+        "bbox": [
+            173,
+            675,
+            825,
+            746
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations, 2015. ",
+        "bbox": [
+            169,
+            755,
+            825,
+            784
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. International Conference on Learning Representations, 2017. ",
+        "bbox": [
+            171,
+            791,
+            825,
+            821
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zornitsa Kozareva, Boyan Bonev, and Andres Montoyo. Self-training and co-training applied to spanish named entity recognition. In Mexican International conference on Artificial Intelligence, pp. 770–779. Springer, 2005. ",
+        "bbox": [
+            174,
+            829,
+            825,
+            872
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dong-Hyun Lee. Pseudo-label: The simple and efficient semi-supervised learning method for deep neural networks. In Workshop on Challenges in Representation Learning, ICML, volume 3, pp. 2, 2013. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jurica Levatic, Michelangelo Ceci, Dragi Kocev, and Sašo Džeroski. Self-training for multi-target ´ regression with tree ensembles. Knowledge-Based Systems, 123:41–60, 2017. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi-supervised learning. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Qian Liu, Bingyang Liu, Dayong Wu, Yue Liu, and Xueqi Cheng. A self-learning template approach for recognizing named entities from web text. In Proceedings of the Sixth International Joint Conference on Natural Language Processing, pp. 1139–1143, 2013a. ",
+        "bbox": [
+            176,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhiguang Liu, Xishuang Dong, Yi Guan, and Jinfeng Yang. Reserved self-training: A semi-supervised sentiment classification method for chinese microblogs. In Proceedings of the Sixth International Joint Conference on Natural Language Processing, pp. 455–462, 2013b. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            273
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David McClosky, Eugene Charniak, and Mark Johnson. Effective self-training for parsing. In Proceedings of the main conference on human language technology conference of the North American Chapter of the Association of Computational Linguistics, pp. 152–159. Association for Computational Linguistics, 2006. ",
+        "bbox": [
+            173,
+            281,
+            826,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David McClosky, Eugene Charniak, and Mark Johnson. When is self-training effective for parsing? In Proceedings of the 22nd International Conference on Computational Linguistics-Volume 1, pp. 561–568. Association for Computational Linguistics, 2008. ",
+        "bbox": [
+            174,
+            347,
+            826,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Federico Monti, Davide Boscaini, Jonathan Masci, Emanuele Rodola, Jan Svoboda, and Michael M Bronstein. Geometric deep learning on graphs and manifolds using mixture model cnns. In Proc. CVPR, volume 1, pp. 3, 2017. ",
+        "bbox": [
+            173,
+            397,
+            826,
+            441
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kamal Nigam, Andrew Kachites McCallum, Sebastian Thrun, and Tom Mitchell. Text classification from labeled and unlabeled documents using em. Machine learning, 39(2-3):103–134, 2000. ",
+        "bbox": [
+            171,
+            449,
+            823,
+            479
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. Deepwalk: Online learning of social representations. In Proceedings of the 20th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 701–710. ACM, 2014. ",
+        "bbox": [
+            173,
+            487,
+            823,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yanjun Qi, Pavel Kuksa, Ronan Collobert, Kunihiko Sadamasa, Koray Kavukcuoglu, and Jason Weston. Semi-supervised sequence labeling with self-learned features. In 2009 Ninth IEEE International Conference on Data Mining, pp. 428–437. IEEE, 2009. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ellen Riloff, Rosie Jones, et al. Learning dictionaries for information extraction by multi-level bootstrapping. In AAAI/IAAI, pp. 474–479, 1999. ",
+        "bbox": [
+            169,
+            589,
+            825,
+            619
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ellen Riloff, Janyce Wiebe, and Theresa Wilson. Learning subjective nouns using extraction pattern bootstrapping. In Proceedings of the seventh conference on Natural language learning at HLTNAACL 2003-Volume 4, pp. 25–32. Association for Computational Linguistics, 2003. ",
+        "bbox": [
+            176,
+            627,
+            825,
+            671
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chuck Rosenberg, Martial Hebert, and Henry Schneiderman. Semi-supervised self-training of object detection models. WACV/MOTION, 2, 2005. ",
+        "bbox": [
+            171,
+            679,
+            825,
+            708
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kenji Sagae. Self-training without reranking for parser domain adaptation and its impact on semantic role labeling. In Proceedings of the 2010 Workshop on Domain Adaptation for Natural Language Processing, pp. 37–44. Association for Computational Linguistics, 2010. ",
+        "bbox": [
+            174,
+            717,
+            825,
+            761
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H Scudder. Probability of error of some adaptive pattern-recognition machines. IEEE Transactions on Information Theory, 11(3):363–371, 1965. ",
+        "bbox": [
+            171,
+            768,
+            825,
+            797
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. Collective classification in network data. AI magazine, 29(3):93–93, 2008. ",
+        "bbox": [
+            171,
+            805,
+            825,
+            835
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. Pitfalls of graph neural network evaluation. CoRR, abs/1811.05868, 2018. URL http://arxiv.org/ abs/1811.05868. ",
+        "bbox": [
+            173,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ke Sun, Zhanxing Zhu, and Zhouchen Lin. Multi-stage self-supervised learning for graph convolutional networks. arXiv preprint arXiv:1902.11038, 2019. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jian Tang, Meng Qu, Mingzhe Wang, Ming Zhang, Jun Yan, and Qiaozhu Mei. Line: Large-scale information network embedding. In Proceedings of the 24th International Conference on World Wide Web, pp. 1067–1077, 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Vincent Van Asch and Walter Daelemans. Predicting the effectiveness of self-training: Application to sentiment classification. arXiv preprint arXiv:1601.03288, 2016. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Petar Velickovi ˇ c, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon ´ Hjelm. Deep graph infomax. International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daixin Wang, Peng Cui, and Wenwu Zhu. Structural deep network embedding. In Proceedings of the 22nd ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 1225–1234. ACM, 2016. ",
+        "bbox": [
+            174,
+            267,
+            825,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wen Wang, Zhongqiang Huang, and Mary Harper. Semi-supervised learning for part-of-speech tagging of mandarin transcribed speech. In 2007 IEEE International Conference on Acoustics, Speech and Signal Processing-ICASSP’07, volume 4, pp. IV–137. IEEE, 2007. ",
+        "bbox": [
+            173,
+            319,
+            823,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. Simplifying graph convolutional networks. In International Conference on Machine Learning, pp. 6861–6871, 2019. ",
+        "bbox": [
+            173,
+            371,
+            825,
+            414
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Keyulu Xu, Chengtao Li, Yonglong Tian, Tomohiro Sonobe, Ken-ichi Kawarabayashi, and Stefanie Jegelka. Representation learning on graphs with jumping knowledge networks. International Conference on Machine Learning, 2018. ",
+        "bbox": [
+            173,
+            422,
+            826,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Yarowsky. Unsupervised word sense disambiguation rivaling supervised methods. In 33rd annual meeting of the association for computational linguistics, 1995. ",
+        "bbox": [
+            173,
+            474,
+            823,
+            503
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yan Zhou, Murat Kantarcioglu, and Bhavani Thuraisingham. Self-training with selection-by-rejection. In 2012 IEEE 12th international conference on data mining, pp. 795–803. IEEE, 2012. ",
+        "bbox": [
+            173,
+            511,
+            823,
+            541
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xiaojin Zhu, Zoubin Ghahramani, and John D Lafferty. Semi-supervised learning using gaussian fields and harmonic functions. In Proceedings of the 20th International conference on Machine learning, pp. 912–919, 2003. ",
+        "bbox": [
+            173,
+            549,
+            826,
+            593
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX: ADDITIONAL EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            545,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We also test our self-training methods on other GNNs as well, e.g., SGC(Wu et al., 2019), GAT (Velickovic et al., 2018), and GraphSage (Hamilton et al., 2017). For the three GNN models, settings of hyper-parameters are the same as suggested in original papers. And our dynamic self-training framework share the same setting of hyper-parameter: one hidden layer with 32 units, dropout rate 0.7, Adam optimizer (Kingma & Ba, 2015), a $L _ { 2 }$ regularization with weight $5 ^ { - 4 }$ and set the threshold to 0.9. Clearly, our dynamic self-training framework achieves similar improvements on all the three base models. The numerical results are summarized in Table 4. We can see equipped with our DS framework, these models enjoys noticeable increase in performance. ",
+        "bbox": [
+            173,
+            132,
+            825,
+            246
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/66ac4e47318abf15760d3ec05fe632123847018e119b7f08ddf6c0e5e372de29.jpg",
+        "table_caption": [
+            "Table 4: Summary of results in terms of mean classification accuracy (in percent) over 50 random splits in different tasks(the results of GAT experiments are from Table 2). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"4\">Citeseer</td><td colspan=\"4\">Cora</td></tr><tr><td># ofLabels</td><td>5</td><td>10</td><td>20</td><td>50</td><td>5</td><td>10</td><td>20</td><td>50</td></tr><tr><td>SGC</td><td>55.5</td><td>63.7</td><td>69.0</td><td>72.6</td><td>63.5</td><td>72.5</td><td>75.9</td><td>78.9</td></tr><tr><td>DS-SGC</td><td>59.6</td><td>65.0</td><td>69.7</td><td>73.4</td><td>65.0</td><td>73.4</td><td>76.2</td><td>78.9</td></tr><tr><td>GAT DS-GAT</td><td>54.9</td><td>60.8</td><td>68.2</td><td>71.5</td><td>71.1</td><td>76.0</td><td>79.6</td><td>83.4</td></tr><tr><td></td><td>58.3</td><td>67.0</td><td>70.8</td><td>73.4</td><td>71.9</td><td>77.1</td><td>81.0</td><td>83.6</td></tr><tr><td>GraphSAGE</td><td>59.7</td><td>65.4</td><td>68.8</td><td>72.1</td><td>69.3</td><td>75.3</td><td>79.2</td><td>82.5</td></tr><tr><td>DS-GraphSAGE</td><td>60.6</td><td>66.3</td><td>69.5</td><td>72.6</td><td>72.5</td><td>78.4</td><td>81.0</td><td>84.0</td></tr></table>",
+        "bbox": [
+            250,
+            301,
+            746,
+            433
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the computation overhead introduced by dynamic self-training framework, we test the total training time for various models. Intuitively the computational cost will only slightly increase. The reason is that the computational cost of the original GCN model is dominated by previous layers, where the entire graph is included. So even if all nodes become pseudo labels, the size of the entire network is increased by at most a factor of 2, and the number of parameters remains the same. Therefore, the computational costs will increase by at most a small constant in theory. We have also verified this empirically. We record the training time of base models before and after applying our framework. In the experiments, the training size is 20 per class, the number of epoch is 200, and the time is the average time (in seconds) of 25 runs. The numerical results can be seen in Tabel 5. ",
+        "bbox": [
+            173,
+            452,
+            826,
+            578
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/20dd2ec1c62311d0bb81055e47f3fcd24786636761508cd60bf51b4dcfb86929.jpg",
+        "table_caption": [
+            "Table 5: Total training time for various models in seconds(s), implemented on PyG. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Citeseer</td><td>Cora</td></tr><tr><td>GCN</td><td>3.0</td><td>2.6</td></tr><tr><td>DSGCN</td><td>9.7</td><td>6.3</td></tr><tr><td>SGC</td><td>1.4</td><td>1.3</td></tr><tr><td>DS-SGC</td><td>7.1</td><td>7.4</td></tr><tr><td>GAT</td><td>5.2</td><td>4.7</td></tr><tr><td>DS-GAT</td><td>11.9</td><td>8.7</td></tr><tr><td>GraphSAGE</td><td>1.9</td><td>2.1</td></tr><tr><td>DS-GraphSAGE</td><td>8.7</td><td>8.5</td></tr></table>",
+        "bbox": [
+            372,
+            619,
+            624,
+            763
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJlh8CEYDB/SJlh8CEYDB.md

@@ -0,0 +1,438 @@
+# LEARN TO EXPLAIN EFFICIENTLY VIA NEURAL LOGIC INDUCTIVE LEARNING
+
+Yuan Yang & Le Song   
+Georgia Institute of Technology   
+yyang754@gatech.edu, lsong@cc.gatech.edu
+
+# ABSTRACT
+
+The capability of making interpretable and self-explanatory decisions is essential for developing responsible machine learning systems. In this work, we study the learning to explain problem in the scope of inductive logic programming (ILP). We propose Neural Logic Inductive Learning (NLIL), an efficient differentiable ILP framework that learns first-order logic rules that can explain the patterns in the data. In experiments, compared with the state-of-the-art methods, we find NLIL can search for rules that are $\mathbf { x } 1 0$ times longer while remaining ${ \bf X } { \boldsymbol 3 }$ times faster. We also show that NLIL can scale to large image datasets, i.e. Visual Genome, with 1M entities.
+
+# 1 INTRODUCTION
+
+![](images/53938345393f74ae7f1529abeffdd37a9b841ca801cfdb53f2b1de158416bfec.jpg)  
+Figure 1: A scene-graph can describe the relations of objects in an image. The NLIL can utilize this graph and explain the presence of objects Car and Person by learning the first-order logic rules that characterize the common sub-patterns in the graph. The explanation is globally consistent and can be interpreted as commonsense knowledge.
+
+The recent years have witnessed the growing success of deep learning models in a wide range of applications. However, these models are also criticized for the lack of interpretability in its behavior and decision making process (Lipton, 2016; Mittelstadt et al., 2019), and for being data-hungry. The ability to explain its decision is essential for developing a responsible and robust decision system (Guidotti et al., 2019). On the other hand, logic programming methods, in the form of first-order logic (FOL), are capable of discovering and representing knowledge in explicit symbolic structure that can be understood and examined by human (Evans & Grefenstette, 2018).
+
+In this paper, we investigate the learning to explain problem in the scope of inductive logic programming (ILP) which seeks to learn first-order logic rules that explain the data. Traditional ILP methods (Galarraga et al., 2015) rely on hard matching and discrete logic for rule search which is ´ not tolerant for ambiguous and noisy data (Evans & Grefenstette, 2018). A number of works are proposed for developing differentiable ILP models that combine the strength of neural and logicbased computation (Evans & Grefenstette, 2018; Campero et al., 2018; Rocktaschel & Riedel, 2017; ¨ Payani & Fekri, 2019; Dong et al., 2019). Methods such as ∂ILP (Evans & Grefenstette, 2018) are referred to as forward-chaining methods. It constructs rules using a set of pre-defined templates and evaluates them by applying the rule on background data multiple times to deduce new facts that lie in the held-out set (related works available at Appendix A). However, general ILP problem involves several steps that are NP-hard: (i) the rule search space grows exponentially in the length of the rule; (ii) assigning the logic variables to be shared by predicates grows exponentially in the number of arguments, which we refer as variable binding problem; (iii) the number of rule instantiations needed for formula evaluation grows exponentially in the size of data. To alleviate these complexities, most works have limited the search length to within 3 and resort to template-based variable assignments, limiting the expressiveness of the learned rules (detailed discussion available at Appendix B). Still, most of the works are limited in small scale problems with less than 10 relations and 1K entities.
+
+On the other hand, multi-hop reasoning methods (Guu et al., 2015; Lao & Cohen, 2010; Lin et al., 2015; Gardner & Mitchell, 2015; Das et al., 2016) are proposed for the knowledge base (KB) completion task. Methods such as NeuralLP (Yang et al., 2017) can answer the KB queries by searching for a relational path that leads from the subject to the object. These methods can be interpreted in the ILP domain where the learned relational path is equivalent to a chain-like first-order rule. Compared to the template-based counterparts, methods such as NeuralLP is highly efficient in variable binding and rule evaluation. However, they are limited in two aspects: (i) the chain-like rules represent a subset of the Horn clauses, and are limited in expressing complex rules such as those shown in Figure 1; (ii) the relational path is generated while conditioning on the specific query, meaning that the learned rule is only valid for the current query. This makes it difficult to learn rules that are globally consistent in the KB, which is an important aspect of a good explanation.
+
+In this work, we propose Neural Logic Inductive Learning (NLIL), a differentiable ILP method that extends the multi-hop reasoning framework for general ILP problem. NLIL is highly efficient and expressive. We propose a divide-and-conquer strategy and decompose the search space into 3 subspaces in a hierarchy, where each of them can be searched efficiently using attentions. This enables us to search for $\mathbf { x } 1 0$ times longer rules while remaining x3 times faster than the state-of-theart methods. We maintain the global consistency of rules by splitting the training into rule generation and rule evaluation phase, where the former is only conditioned on the predicate type that is shared globally.
+
+And more importantly, we show that a scalable ILP method is widely applicable for model explanations in supervised learning scenario. We apply NLIL on Visual Genome (Krishna et al., 2016) dataset for learning explanations for 150 object classes over 1M entities. We demonstrate that the learned rules, while maintaining the interpretability, have comparable predictive power as densely supervised models, and generalize well with less than $1 \%$ of the data.
+
+# 2 PRELIMINARIES
+
+Supervised learning typically involves learning classifiers that map an object from its input space to a score between 0 and 1. How can one explain the outcome of a classifier? Recent works on interpretability focus on generating heatmaps or attention that self-explains a classifier (Ribeiro et al., 2016; Chen et al., 2018; Olah et al., 2018). We argue that a more effective and humanintelligent explanation is through the description of the connection with other classifiers.
+
+For example, consider an object detector with classifiers $\mathtt { P e r s o n } ( X )$ , $\mathtt { C a r } ( X )$ , Clothing $( X )$ and Inside $( X , X ^ { \prime } )$ that detects if certain region contains a person, a car, a clothing or is inside another region, respectively. To explain why a person is present, one can leverage its connection with other attributes, such as $\boldsymbol { \cdot } _ { X }$ is a person if it’s inside a car and wearing clothing”, as shown in Figure 1. This intuition draws a close connection to a longstanding problem of first-order logic literature, i.e. Inductive Logic Programming (ILP).
+
+# 2.1 INDUCTIVE LOGIC PROGRAMMING
+
+A typical first-order logic system consists of 3 components: entity, predicate and formula. Entities are objects $\mathbf { x } \in \mathcal { X }$ . For example, for a given image, a certain region is an entity $\mathbf { x }$ , and the set of all possible regions is $\mathcal { X }$ . Predicates are functions that map entities to 0 or 1, for example Person : $\mathbf { x } \mapsto \{ 0 , 1 \}$ , $\mathbf { x } \in \mathcal { X }$ . Classifiers can be seen as soft predicates. Predicates can take multiple arguments, e.g. Inside is a predicate with 2 inputs. The number of arguments is referred to as the arity. Atom is a predicate symbol applied to a logic variable, e.g. $\mathsf { P e r s o n } ( X )$ and Inside $( X , X ^ { \prime } )$ . A logic variable such as $X$ can be instantiated into any object in $\mathcal { X }$ .
+
+A first-order logic (FOL) formula is a combination of atoms using logical operations $\{ \land , \lor , \lnot \}$ which correspond to logic and, or and not respectively. Given a set of predicates $\begin{array} { r l } { \mathcal { P } } & { { } = } \end{array}$ $\{ P _ { 1 } , . . . , P _ { K } \}$ , we define the explanation of a predicate $P _ { k }$ as a first-order logic entailment
+
+$$
+\forall X , X ^ { \prime } \exists Y _ { 1 } , Y _ { 2 } . . . P _ { k } ( X , X ^ { \prime } )  A ( X , X ^ { \prime } , Y _ { 1 } , Y _ { 2 } . . . ) ,
+$$
+
+where $P _ { k } ( X , X ^ { \prime } )$ is the head of the entailment, and it will become $P _ { k } ( X )$ if it is a unary predicate. $A$ is defined as the rule body and is a general formula, e.g. conjunction normal form (CNF), that is made of atoms with predicate symbols from $\mathcal { P }$ and logic variables that are either head variables $X$ , $X ^ { \prime }$ or one of the body variables $\mathcal { V } = \{ Y _ { 1 } , Y _ { 2 } , . . . \}$ .
+
+By using the logic variables, the explanation becomes transferrable as it represents the “lifted” knowledge that does not depend on the specific data. It can be easily interpreted. For example,
+
+$$
+\mathtt { P e r s o n } ( X ) \gets \mathtt { I n s i d e } ( X , Y _ { 1 } ) \wedge \mathtt { C a r } ( Y _ { 1 } ) \wedge \mathtt { O n } ( Y _ { 2 } , X ) \wedge \mathtt { C l o t h i n g } ( Y _ { 2 } )
+$$
+
+represents the knowledge that “if an object is inside the car with clothing on it, then it’s a person”. To evaluate a formula on the actual data, one grounds the formula by instantiating all the variables into objects. For example, in Figure 1, Eq.(2) is applied to the specific regions of an image.
+
+Given a relational knowledge base (KB) that consists of a set of facts $\{ \langle \mathbf { x } _ { i } , P _ { i } , \mathbf { x } _ { i } ^ { \prime } \rangle \} _ { i = 1 } ^ { N }$ where $P _ { i } \in \mathcal { P }$ and $\mathbf { x } _ { i } , \mathbf { x } _ { i } ^ { \prime } \in \mathcal { X }$ . The task of learning FOL rules in the form of Eq.(1) that entail target predicate $P ^ { * } \in \mathcal { P }$ is called inductive logic programming. For simplicity, we consider unary and binary predicates for the following contents, but this definition can be extended to predicates with higher arity as well.
+
+# 2.2 MUTLI-HOP REASONING
+
+The ILP problem is closely related to the multi-hop reasoning task on the knowledge graph (Guu et al., 2015; Lao & Cohen, 2010; Lin et al., 2015; Gardner & Mitchell, 2015; Das et al., 2016). Similar to ILP, the task operates on a KB that consists of a set of predicates $\mathcal { P }$ . Here the facts are stored with respect to the predicate $P _ { k }$ which is represented as a binary matrix ${ { \bf { M } } _ { k } }$ in $\{ 0 , 1 \} ^ { | \mathcal { X } | \times | \mathcal { X } | }$ . This is an adjacency matrix, meaning that $\langle \mathbf { x } _ { i } , P _ { k } , \mathbf { x } _ { j } \rangle$ is in the KB if and only if the $( i , j )$ entry of ${ { \bf { M } } _ { k } }$ is 1.
+
+Given a query $q = \langle \mathbf { x } , P ^ { * } , \mathbf { x } ^ { \prime } \rangle$ . The task is to find a relational path $\textbf { x } \xrightarrow { P ^ { ( 1 ) } } \dots \xrightarrow { P ^ { ( T ) } } \textbf { x } ^ { \prime }$ , such that the two query entities are connected. Formally, let $\mathbf { v _ { x } }$ be the one-hot encoding of object $\mathbf { x }$ with dimension of $| \mathcal { X } |$ . Then, the $( t )$ th hop of the reasoning along the path is represented as
+
+$$
+\mathbf { v } ^ { ( 0 ) } = \mathbf { v } _ { \mathbf { x } } , \qquad \mathbf { v } ^ { ( t ) } = \mathbf { M } ^ { ( t ) } \mathbf { v } ^ { ( t - 1 ) } ,
+$$
+
+where $\mathbf { M } ^ { ( t ) }$ is the adjacency matrix of the predicate used in $( t )$ th hop. The $\mathbf { v } ^ { ( t ) }$ is the path features vector, where the jth element v(t)j counts the number of unique paths from $\mathbf { x }$ to $\mathbf { x } _ { j }$ (Guu et al., 2015). After $T$ steps of reasoning, the score of the query is computed as
+
+$$
+\operatorname { s c o r e } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \mathbf { v } _ { \mathbf { x } ^ { \prime } } ^ { \top } \prod _ { t = 1 } ^ { T } \mathbf { M } ^ { ( t ) } \cdot \mathbf { v } _ { \mathbf { x } } .
+$$
+
+For each $q$ , the goal is to (i) find an appropriate $T$ and (ii) for each $t \in [ 1 , 2 , . . . , T ]$ , find the appropriate $\mathbf { M } ^ { ( t ) }$ to multiply, such that Eq.(3) is maximized. These two discrete picks can be relaxed as learning the weighted sum of scores from all possible paths, and weighted sum of matrices at each step. Let
+
+$$
+\kappa ( \mathbf { s } _ { \psi } , \mathbf { S } _ { \varphi } ) \equiv \sum _ { t ^ { \prime } = 1 } ^ { T } s _ { \psi } ^ { ( t ^ { \prime } ) } \left( \prod _ { t = 1 } ^ { t ^ { \prime } } \sum _ { k = 1 } ^ { K } s _ { \varphi , k } ^ { ( t ) } \mathbf { M } _ { k } \right)
+$$
+
+be the soft path selection function parameterized by (i) the path attention vector $\begin{array} { r l } { \mathbf { s } _ { \psi } } & { { } = } \end{array}$ $[ s _ { \psi } ^ { ( 1 ) } , . . . , s _ { \psi } ^ { ( T ) } ] ^ { \intercal }$ that softly picks the best path with length between 1 to $\mathrm { T }$ that answers the query, and (ii) the operator attention vectors $\mathbf { S } _ { \varphi } = [ \mathbf { s } _ { \varphi } ^ { ( 1 ) } , . . . , \mathbf { s } _ { \varphi } ^ { ( T ) } ] ^ { \top }$ s(T )ϕ ]>, where s(t)ϕ softly picks the $\mathbf { M } ^ { ( t ) }$ at $( t ) { \mathrm { t h } }$ step. Here we omit the dependence on $M _ { k }$ for notation clarity. These two attentions are generated with a model
+
+$$
+\mathbf { s } _ { \psi } , \mathbf { S } _ { \varphi } = \mathbb { T } ( \mathbf { x } ; \mathbf { w } )
+$$
+
+with learnable parameters w. For methods such as (Guu et al., 2015; Lao & Cohen, 2010), $\mathbb { T } ( \mathbf { x } ; \mathbf { w } )$ is a random walk sampler which generates one-hot vectors that simulate the random walk on the graph starting from x. And in NeuralLP (Yang et al., 2017), $\mathbb { T } ( \mathbf { x } ; \mathbf { w } )$ is an RNN controller that generates a sequence of normalized attention vectors with $\mathbf { v _ { x } }$ as the initial input. Therefore, the objective is defined as
+
+$$
+\underset { \mathbf { w } } { \arg \operatorname* { m a x } } \sum _ { q } \mathbf { v } _ { \mathbf { x } ^ { \prime } } ^ { \top } \kappa \big ( \mathbf { s } _ { \psi } , \mathbf { S } _ { \varphi } \big ) \mathbf { v } _ { \mathbf { x } } ,
+$$
+
+Learning the relational path in the multi-hop reasoning can be interpreted as solving an ILP problem with chain-like FOL rules (Yang et al., 2017)
+
+$$
+P ^ { * } ( X , X ^ { \prime } )  P ^ { ( 1 ) } ( X , Y _ { 1 } ) \land P ^ { ( 2 ) } ( Y _ { 1 } , Y _ { 2 } ) \land \ldots \land P ^ { ( T ) } ( Y _ { n - 1 } , X ^ { \prime } ) .
+$$
+
+Compared to the template-based ILP methods such as ∂ILP, this class of methods is efficient in rule exploration and evaluation. However, $( \mathbf { P 1 } )$ generating explanations for supervised models puts a high demand on the rule expressiveness. The chain-like rule space is limited in its expressive power because it represents a constrained subspace of the Horn clauses rule space. For example, Eq.(2) is a Horn clause and is not chain-like. And the ability to efficiently search beyond the chain-like rule space is still lacking in these methods. On the other hand, (P2) the attention generator $\mathbb { T } ( \mathbf { x } ; \mathbf { w } )$ is dependent on $\mathbf { x }$ , the subject of a specific query $q$ , meaning that the explanation generated for target $P ^ { * }$ can vary from query to query. This makes it difficult to learn FOL rules that are globally consistent in the KB.
+
+# 3 NEURAL LOGIC INDUCTIVE LEARNING
+
+In this section, we show the connection between the multi-hop reasoning methods with the general logic entailment defined in Eq.(1). Then we propose a hierarchical rule space to solve (P1), i.e. we extend the chain-like space for efficient learning of more expressive rules.
+
+# 3.1 THE OPERATOR VIEW
+
+In Eq.(1), variables that only appear in the body are under existential quantifier. We can turn Eq.(1) into Skolem normal form by replacing all variables under existential quantifier with functions with respect to $X$ and $X ^ { \prime }$ ,
+
+$$
+\forall X , X ^ { \prime } \exists \varphi _ { 1 } , \varphi _ { 2 } , \ldots P ^ { * } ( X , X ^ { \prime } )  A ( X , X ^ { \prime } , \varphi _ { 1 } ( X ) , \varphi _ { 1 } ( X ^ { \prime } ) , \varphi _ { 2 } ( X ) , \ldots ) .
+$$
+
+If the functions are known, Eq.(7) will be much easier to evaluate than Eq.(1). Because grounding this formula only requires to instantiate the head variables, and the rest of the body variables are then determined by the deterministic functions.
+
+Functions in Eq.(7) can be arbitrary. But what are the functions that one can utilize? We propose to adopt the notions in section 2.2 and treat each predicate as an operator, such that we have a subspace of the functions $\Phi = \{ \varphi _ { 1 } , . . . , \varphi _ { K } \}$ , where
+
+$$
+\left\{ \begin{array} { l l } { \varphi _ { k } ( \boldsymbol { \mathbf { \rho } } ) = \mathbf { M } _ { k } \ \mathbf { 1 } \quad } & { \mathrm { i f } \ k \in \mathcal { U } , } \\ { \varphi _ { k } ( \mathbf { v _ { x } } ) = \mathbf { M } _ { k } \mathbf { v _ { x } } \quad } & { \mathrm { i f } \ k \in \mathcal { B } , } \end{array} \right.
+$$
+
+where $\mathcal { U }$ and $\boldsymbol { B }$ are the sets of unary and binary predicates respectively. The operator of the unary predicate takes no input and is parameterized with a diagonal matrix. Intuitively, given a subject entity $\mathbf { x }$ , $\varphi _ { k }$ returns the set embedding (Guu et al., 2015) that represents the object entities that, together with the subject, satisfy the predicate $P _ { k }$ . For example, let $\mathbf { v _ { x } }$ be the one-hot encoding of an object in the image, then $\varphi _ { \mathrm { I n s i d e } } ( \mathbf { v _ { x } } )$ returns the objects that spatially contain the input box. For unary predicate such as $\mathtt { C a r } ( X )$ , its operator $\varphi _ { \mathtt { C a r } } ( \ r ) = \mathbf { M } _ { \mathtt { c a r } } \mathbf { 1 }$ takes no input and returns the set of all objects labelled as car.
+
+Since we only use $\Phi$ , a subspace of the functions, the existential variables that can be represented by the operator calls, denoted as $\hat { \mathcal { V } }$ , also form the subset $\hat { \mathcal { V } } \subseteq \mathcal { V }$ . This is slightly constrained from Eq.(1). For example, in $\mathtt { P e r s o n } ( X )  \mathtt { C a r } ( Y ) ,$ $Y$ can not be interpreted as the operator call from $X$ . However, we argue that such rules are generally trivial. For example, it’s not likely to infer “an image contains a person” by simply checking if “there is any car in the image”.
+
+Therefore, any FOL formula that complies with Eq.(7) can now be converted into the operator form and vice versa. For example, Eq.(2) can be written as
+
+$$
+\mathtt { P e r s o n } ( X ) \gets \mathtt { C a r } ( \varphi _ { \mathtt { I n s i d e } } ( X ) ) \wedge \mathtt { O n } ( \varphi _ { \mathtt { C l o t h i n g } } ( ) , X ) ,
+$$
+
+where the variable $Y _ { 1 }$ and $Y _ { 2 }$ are eliminated. Note that this conversion is not unique. For example, $\mathtt { C a r } ( \varphi _ { \mathtt { I n s i d e } } ( X ) )$ can be also written as Inside $( X , \varphi _ { \mathtt { C a r } } ( ) )$ . The variable binding problem now becomes equivalent to the path-finding problem in section 2.2, where one searches for the appropriate chain of operator calls that can represent the variable in $\hat { \mathcal { V } }$ .
+
+# 3.2 PRIMITIVE STATEMENTS
+
+![](images/eb2f5d21e1135794556ca7b84841c51082cde04b9508af4b15e6c1bd15c77a17.jpg)  
+Figure 2: Factor graphs of example chainlike, tree-like and conjunctions of rules. Each rule type is the subset of the latter. Succ stands for successor.
+
+As discussed above, the Eq.(3) is equivalent to a chain-like rule. We want to extend this notion and be able to represent more expressive rules. To do this, we introduce the notion of primitive statement $\psi$ . Note that an atom is defined as a predicate symbol applied to specific logic variables. Similarly, we define a predicate symbol applied to the head variables or those in $\hat { \mathcal { V } }$ as a primitive statement. For example, in Eq.(8), $\psi _ { 1 } \ { \overset { \cdot } { = } } \ \complement \complement ( \varphi _ { \mathrm { I n s i d e } } ( X ) )$ and $\psi _ { 2 } = \mathrm { O n } ( \varphi _ { \mathrm { C l o t h i n g } } ( ) , X )$ are two primitive statements.
+
+Similar to an atom, each primitive statement is a mapping from the input space to a scalar confidence score, i.e. $\psi ~ : ~ \hat { \mathbb { R } } ^ { | \mathcal { X } | } \ \times ~ \mathbb { R } ^ { | \mathcal { X } | } \ \mapsto \ s ~ \in$ $[ 0 , 1 ]$ . Formally, for a unary primitive statement $P _ { k } ( \varphi ^ { ( T ^ { \prime } ) } \cdot \ldots \cdot \varphi ^ { ( 1 ) } ( \mathbf { x } ^ { \prime } ) )$ and a binary one $P _ { k } \mathopen { } \mathclose \bgroup \left( \varphi ^ { ( T ) } \aftergroup \egroup \right)$ · $\dots \cdot \varphi ^ { ( 1 ) } ( \mathbf { x } ) , \varphi ^ { ( T ^ { \prime } ) } \cdot \dots \cdot \varphi ^ { ( 1 ) } ( \mathbf { x } ^ { \prime } ) )$ , their mappings are defined as
+
+$$
+\begin{array} { r } { \psi _ { k } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \left\{ \begin{array} { l l } { \sigma ( ( \mathbf { M } _ { k } \mathbf { 1 } ) ^ { \top } ( \prod _ { t ^ { \prime } = 1 } ^ { T ^ { \prime } } \mathbf { M } ^ { ( t ^ { \prime } ) } \mathbf { v } _ { \mathbf { x } ^ { \prime } } ) ) \quad } & { \mathrm { ~ i f ~ } k \in \mathcal { U } , } \\ { \sigma ( ( \mathbf { M } _ { k } \prod _ { t = 1 } ^ { T } \mathbf { M } ^ { ( t ) } \mathbf { v } _ { \mathbf { x } } ) ^ { \top } ( \prod _ { t ^ { \prime } = 1 } ^ { T ^ { \prime } } \mathbf { M } ^ { ( t ^ { \prime } ) } \mathbf { v } _ { \mathbf { x } ^ { \prime } } ) ) \quad } & { \mathrm { ~ i f ~ } k \in \mathcal { B } , } \end{array} \right. } \end{array}
+$$
+
+where $\sigma ( \cdot )$ is the sigmoid function. Note that we give unary $\psi$ a dummy input $\mathbf { x }$ for notation convenience. For example, in
+
+$$
+\mathtt { E a r } ( X )  \mathtt { E y e } ( Y _ { 1 } ) \land \mathtt { O f } ( Y _ { 1 } , Y _ { 2 } ) \land \mathtt { O f } ( X , Y _ { 2 } ) ,
+$$
+
+the body is a single statement $\begin{array} { r l r } { \psi } & { { } = } & { \ O \mathrm { f } \left( \varphi _ { \mathrm { E y e } } ( ) , \varphi _ { \mathrm { O f } } ( X ) \right) } \end{array}$ . Its value is computed as $\psi _ { 0 \mathrm { f } } ( \varphi _ { \mathrm { E y e } } ( ) , \varphi _ { 0 \mathrm { f } } ( \mathbf { v _ { x ^ { \prime } } } ) ) = \sigma ( ( \mathbf { M } _ { 0 \mathrm { f } } \mathbf { M } _ { \mathrm { E y e } } \mathbf { 1 } ) ^ { \top } ( \mathbf { M } _ { 0 \mathrm { f } } \mathbf { v } _ { \mathbf { x ^ { \prime } } } ) )$ . Compared to Eq.(3), Eq.(9) replaces the target $\mathbf { v } _ { \mathbf { x } ^ { \prime } }$ into another relational path. This makes it possible to represent “correlations” between two variables, and the path that starts from the unary operator, e.g. $\varphi _ { \mathrm { E y e } } ( )$ . To see this, one can view a FOL rule as a factor graph with logic variables as the nodes and predicates as the potentials (Cohen et al., 2017). And running the operator call is essentially conducting the belief propagation over the graph in a fixed direction. As shown in Figure 2, primitive statement is capable of representing the tree-like factor graphs, which significantly improves the expressive power of the learned rules.
+
+Similarly, Eq.(9) can be relaxed into weighted sums. In Eq.(6), all relational paths are summed with a single path attention vector ${ \bf s } _ { \psi }$ . We extend this notion by assigning separate vectors for each argument of the statement $\psi$ . Let $\mathbf { S } _ { \psi } , \mathbf { S } _ { \psi } ^ { \prime } \in \mathbb { R } ^ { K \times T }$ be the path attention matrices for the first and second argument of all statements in $\Psi$ , i.e. ${ \bf s } _ { \psi , k }$ and $\mathbf { s } _ { \psi , k } ^ { \prime }$ are the path attention vectors of the first and second argument of the $k$ th statement. Then we have
+
+$$
+\psi _ { k } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \left\{ \begin{array} { l l } { \sigma \left( ( \mathbf { M } _ { k } \mathbf { 1 } ) ^ { \top } ( \kappa ( \mathbf { s } _ { \psi , k } ^ { \prime } , \mathbf { S } _ { \varphi } ) \mathbf { v } _ { \mathbf { x } ^ { \prime } } ) \right) } & { \quad \mathrm { i f } \ k \in \mathcal { U } , } \\ { \sigma \left( ( \mathbf { M } _ { k } \kappa ( \mathbf { s } _ { \psi , k } , \mathbf { S } _ { \varphi } ) \mathbf { v } _ { \mathbf { x } } ) ^ { \top } ( \kappa ( \mathbf { s } _ { \psi , k } ^ { \prime } , \mathbf { S } _ { \varphi } ) \mathbf { v } _ { \mathbf { x } ^ { \prime } } ) \right) } & { \quad \mathrm { i f } \ k \in \mathcal { B } . } \end{array} \right.
+$$
+
+# 3.3 LOGIC COMBINATION SPACE
+
+By introducing the primitive statements, we are now one step away from representing the running example rule Eq.(8), which is the logic conjunction of two statements $\psi _ { 1 }$ and $\psi _ { 2 }$ . Specifically,
+
+![](images/b5b03e9d49a116682c9477c2802556c2991d8997cc58a0441c2fe1ead36619d2.jpg)  
+Figure 3: A hierarchical rule space where the operator calls, statement evaluations and logic combinations are all relaxed into the weight sums with respect to attentions $\mathbf { S } _ { \varphi } , \mathbf { S } _ { \psi } , \mathbf { S } _ { \psi } ^ { \prime } , \mathbf { S } _ { f } , \mathbf { S } _ { f } ^ { \prime }$ and ${ \bf s } _ { o }$ . W/sum denotes the weighted sum, Matmul denotes the matrix product, Neg denotes soft logic not, and XEnt denotes the cross-entropy loss.
+
+we want to further extend the rule search space by exploring the logic combinations of primitive statements, via $\{ \land , \lor , \lnot \}$ , as shown in Figure 2. To do this, we utilize the soft logic not and soft logic and operations
+
+$$
+\neg p = 1 - p , \qquad p \wedge q = p \ast q ,
+$$
+
+where $p , q \ \in \ [ 0 , 1 ]$ . Here we do not include the logic $\vee$ operation because it can be implicitly represented as p ∨ q = ¬(¬p ∧ ¬q). Let Ψ = {ψk(x, x0)}Kk=1 be the set of primitive statements with all possible predicate symbols. We define the formula set at lth level as
+
+$$
+\begin{array} { r l } & { \mathcal { F } _ { 0 } = \boldsymbol { \Psi } , } \\ & { \hat { \mathcal { F } } _ { l - 1 } = \mathcal { F } _ { l - 1 } \cup \{ 1 - f ( \mathbf { x } , \mathbf { x } ^ { \prime } ) : f \in \mathcal { F } _ { l - 1 } \} , } \\ & { \mathcal { F } _ { l } = \{ f _ { i } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) \ast f _ { i } ^ { \prime } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) : f _ { i } , f _ { i } ^ { \prime } \in \hat { \mathcal { F } } _ { l - 1 } \} _ { i = 1 } ^ { C } , } \end{array}
+$$
+
+where each element in the formula set $\{ f : f \in \mathscr { F } _ { l } \}$ is called a formula such that $f : \mathbb { R } ^ { | \mathcal { X } | } \times \mathbb { R } ^ { | \mathcal { X } | } \mapsto$ $s \in \ [ 0 , 1 ]$ . Intuitively, we define the logic combination space in a similar way as that in pathfinding: the initial formula set contains only primitive statements $\Psi$ , because they are formulas by themselves. For the $l - 1$ th formula set $\mathcal { F } _ { l - 1 }$ , we concatenate it with its logic negation, which yields $\hat { \mathcal { F } } _ { l - 1 }$ . Then each formula in the next level is the logic and of two formulas from $\hat { \mathcal { F } } _ { l - 1 }$ . Enumerating all possible combinations at each level is expensive, so we set up a memory limitation $C$ to indicate the maximum number of combinations each level can keep track of1. In other words, each level $\mathcal { F } _ { l }$ is to search for $C$ logic and combinations on formulas from the previous level $\hat { \mathcal { F } } _ { l - 1 }$ , such that the cth formula at the lth level $f _ { l c }$ is
+
+$$
+f _ { l c } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = f _ { l - 1 , i } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) * f _ { l - 1 , i } ^ { \prime } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) , \qquad f _ { l - 1 , i } , f _ { l - 1 , i } ^ { \prime } \in \hat { \mathcal { F } } _ { l - 1 } .
+$$
+
+As an example, for $\Psi = \{ \psi _ { 1 } , \psi _ { 2 } \}$ and $C = 2$ , one possible level sequence is $\mathcal { F } _ { 0 } = \{ \psi _ { 1 } , \psi _ { 2 } \}$ , $\mathcal { F } _ { 1 } = \{ \psi _ { 1 } * \psi _ { 2 } , ( 1 - \psi _ { 2 } ) * \psi _ { 1 } \}$ , $\mathcal { \bar { F } } _ { 2 } = \{ ( \psi _ { 1 } * \psi _ { 2 } ) * \bar { ( } ( 1 - \psi _ { 2 } ) * \psi _ { 1 } ) , \bar { . . . } \}$ and etc. To collect the rules from all levels, the final level $L$ is the union of previous sets, i.e. $\mathcal { F } _ { L } = \mathcal { F } _ { 0 } \cup \dotsc \cup \mathcal { F } _ { L - 1 }$ . Note that Eq.(11) does not explicitly forbid trivial rules such as $\psi _ { 1 } * \left( 1 - \psi _ { 1 } \right)$ that is always true regardless of the input. This is alleviated by introducing nonexistent queries during the training (detailed discussion at section 5).
+
+Again, the rule selection can be parameterized into the weighted-sum form with respect to the attentions. We define the formula attention tensors as $\mathbf { S } _ { f } , \mathbf { S } _ { f } ^ { \overline { { \prime } } } \in \mathbb { R } ^ { L - 1 \times C \times 2 C }$ , such that $f _ { l c }$ is the product of two summations over the previous outputs weighted by attention vectors $_ { \mathbf { s } _ { f , l c } }$ and $\mathbf { s } _ { f , l c } ^ { \prime }$ respectively2. Formally, we have
+
+$$
+\begin{array} { r } { f _ { l c } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \mathbf { s } _ { f , l c } ^ { \top } \mathbf { f } _ { l - 1 } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) * \mathbf { s } _ { f , l c } ^ { \prime \top } \mathbf { f } _ { l - 1 } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) , } \end{array}
+$$
+
+where $\mathbf { f } _ { l - 1 } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) \in \mathbb { R } ^ { 2 C }$ is the stacked outputs of all formulas $f \in \hat { \mathcal { F } } _ { l - 1 }$ with arguments $\langle \mathbf { x } , \mathbf { x } ^ { \prime } \rangle$ . Finally, we want to select the best explanation and compute the score for each query. Let ${ \bf s } _ { o }$ be the
+
+![](images/55419236102a6fa3b75f1edeec5fe772c0f09bb27c0ef2ec263aa49718a79bb5.jpg)  
+Figure 4: The hierarchical Transformer networks for attention generation without conditioning on the query.
+
+attention vector over $\mathcal { F } _ { L }$ , so the output score is defined as
+
+$$
+\begin{array} { r } { \mathrm { s c o r e } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) = \mathbf { s } _ { o } ^ { \top } \mathbf { f } _ { L } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) . } \end{array}
+$$
+
+An overview of the relaxed hierarchical rule space is illustrated in Figure 3.
+
+# 4 HIERARCHICAL TRANSFORMER NETWORKS FOR RULE GENERATION
+
+We have defined a hierarchical rule space as shown in Figure 3, where the discrete selections on the operators, statements and logic combinations are all relaxed into the weight sums with respect to a series of attention parameters ${ \bf S } _ { \varphi } , { \bf S } _ { \psi } , { \bf S } _ { \psi } ^ { \prime } , { \bf S } _ { f } , { \bf S } _ { f } ^ { \prime }$ and ${ \bf s } _ { o }$ . In this section, we solve $( \mathbf { P } 2 )$ , i.e. we propose a differentiable model that generates these attentions without conditioning on the specific query.
+
+The goal of NLIL is to generate data-independent FOL rules. In other words, for each target predicate $P ^ { * }$ , its rule set $\mathcal { F } _ { L }$ and the final output rule should remain unchanged for all the queries $q = \langle \mathbf { x } , P ^ { * } , \mathbf { x } ^ { \prime } \rangle$ (which is different from that in Eq.(5)). To do this, we define the learnable embeddings of all predicates as $\mathbf { H } = [ \mathbf { h } _ { 1 } , . . , \mathbf { h } _ { K } ] ^ { \intercal } \in \mathrm { ~ \mathbb { R } ^ { \it K \times d } ~ }$ , and the embeddings for the “dummy” arguments $X$ and $X ^ { \prime }$ as $\mathbf { e } _ { X } , \mathbf { e } _ { X ^ { \prime } } \in \mathbb { R } ^ { d }$ . We define the attention generation model as
+
+$$
+\begin{array} { r } { \mathbf { S } _ { \varphi } , \mathbf { S } _ { \psi } , \mathbf { S } _ { \psi } ^ { \prime } , \mathbf { S } _ { f } , \mathbf { S } _ { f } ^ { \prime } , \mathbf { s } _ { o } = \mathbb { T } ( \mathbf { e } _ { X } , \mathbf { h } ^ { * } , \mathbf { e } _ { X ^ { \prime } } ; \mathbf { w } ) , } \end{array}
+$$
+
+where $\mathbf { h } ^ { * }$ is the embedding of $P ^ { * }$ , such that attentions only vary with respect to $P ^ { * }$ .
+
+As shown in Figure 4, we propose a stack of three Transformer (Vaswani et al., 2017) networks for attention generator $\mathbb { T }$ . Each module is designed to mimic the actual evaluation that could happen during the operator call, primitive statement evaluation and formula computation respectively with neural networks and “dummy” embeddings. And the attention matrices generated during this simulated evaluation process are kept for evaluating Eq.(14). A MultiHeadAttn is a standard Transformer module such that MultiHeadAttn : ${ \bf Q } ^ { q \times \bar { d } } \times \bar { \bf V } ^ { v \times d } \mapsto { \bf O } ^ { q \times d } \times { \bf S } ^ { q \times v }$ , where $d$ is the latent dimension and $q , v$ are the query and value dimensions respectively. It takes the query $\mathbf { Q }$ and input value $\mathbf { V }$ (which will be internally transformed into keys and values), and returns the output value $\mathbf { O }$ and attention matrix S. Intuitively, $\mathbf { S }$ encodes the “compatibility” between query and the value, and $\mathbf { O }$ represents the “outcome” of a query given its compatibility with the input.
+
+Operator search: For target predicate $P ^ { * }$ , we alter the embedding matrix $\mathbf { H }$ with
+
+$$
+\hat { \mathbf { h } } _ { k } = \mathrm { F e e d F o r w a r d } ( \mathrm { C o n c a t } ( \mathbf { h } _ { k } , \mathbf { h } ^ { * } ) ) , \qquad \hat { \mathbf { H } } = [ \hat { \mathbf { h } } _ { 1 } , . . . , \hat { \mathbf { h } } _ { K } ] ^ { \top } ,
+$$
+
+such that the rule generation is predicate-specific. Let $\mathbf { q } _ { \varphi } ^ { ( t ) }$ be the learnable tth step operator query embedding. The operator transformer module is parameterized as
+
+$$
+\begin{array} { r l r l } & { \hat { \mathbf { V } } _ { \varphi } ^ { ( 0 ) } = [ \mathbf { e } _ { X } , \mathbf { e } _ { X ^ { \prime } } ] ^ { \top } , } & & { \hat { \mathbf { Q } } _ { \varphi } = \hat { \mathbf { H } } + \mathbf { e } _ { \varphi } , } \\ & { \hat { \mathbf { V } } _ { \varphi } ^ { ( t ) } , \hat { \mathbf { S } } _ { \varphi } ^ { ( t ) } = \mathrm { M u l t i H e a d A t t n } ( \hat { \mathbf { Q } } _ { \varphi } , \hat { \mathbf { V } } _ { \varphi } ^ { ( t - 1 ) } ) , } & & { \mathbf { v } _ { \varphi } ^ { ( t ) } , \mathbf { s } _ { \varphi } ^ { ( t ) } = \mathrm { M u l t i H e a d A t t n } ( \mathbf { q } _ { \varphi } ^ { ( t ) } , \hat { \mathbf { V } } _ { \varphi } ^ { ( t ) } ) . } \end{array}
+$$
+
+Here, $\hat { \mathbf { V } } _ { \varphi } ^ { ( 0 ) }$ is the dummy input embedding representing the starting points of the paths. $\mathbf { e } _ { \varphi }$ is a learnable operator encoding such that $\hat { \mathbf { Q } } _ { \varphi }$ represents the embeddings of all operators $\Phi$ . Therefore,
+
+Table 1: MRR, Hits $@ 1 0$ and time (mins) of KB completion tasks.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="3">FB15K-237</td><td colspan="3">WN18</td></tr><tr><td>MRR</td><td>Hits @10</td><td>Time</td><td>MRR</td><td>Hits@10</td><td>Time</td></tr><tr><td>NeuralLP</td><td>0.24</td><td>36.2</td><td>250</td><td>0.94</td><td>94.5</td><td>54</td></tr><tr><td>TransE</td><td>0.28</td><td>44.5</td><td>35</td><td>0.57</td><td>93.3</td><td>53</td></tr><tr><td>RotatE</td><td>0.34</td><td>52.6</td><td>342</td><td>0.94</td><td>95.5</td><td>254</td></tr><tr><td>NLIL</td><td>0.25</td><td>32.4</td><td>82</td><td>0.95</td><td>94.6</td><td>12</td></tr></table>
+
+Table 2: Statistics of benchmark KBs and Visual Genome scene-graphs.   
+
+<table><tr><td>KB</td><td>#facts</td><td>#entities</td><td># predicates</td></tr><tr><td>ES-10</td><td>17</td><td>10</td><td>3</td></tr><tr><td>ES-50</td><td>77</td><td>50</td><td>3</td></tr><tr><td>ES-1K</td><td>1.5K</td><td>1K</td><td>3</td></tr><tr><td>WN18</td><td>106K</td><td>40K</td><td>18</td></tr><tr><td>FB15K</td><td>272K</td><td>15K</td><td>237</td></tr><tr><td>VG</td><td>1.9M</td><td>1.4M</td><td>2100</td></tr></table>
+
+we consider that $\hat { \mathbf { V } } _ { \varphi } ^ { ( t ) }$ encodes the outputs of the operator calls of $K$ predicates. And we aggregate the outputs with another MultiHeadAttn with respect to a single query $\mathbf { q } _ { \varphi } ^ { ( t ) }$ , which in turn yields the operator path attention vector $\mathbf { s } _ { \varphi } ^ { ( t ) }$ and aggregated output $\mathbf { v } _ { \varphi } ^ { ( t ) }$ .
+
+Primitive statement search: Let $\mathbf V _ { \varphi } = [ \mathbf v _ { \varphi } ^ { ( 1 ) } , . . . , \mathbf v _ { \varphi } ^ { ( T ) } ] ^ { \top }$ be the output embedding of $T$ paths. The path attention is generated as
+
+$$
+\begin{array} { r l r l } & { \mathbf { Q } _ { \psi } = \hat { \mathbf { H } } + \mathbf { e } _ { \psi } , \mathbf { Q } _ { \psi } ^ { \prime } = \hat { \mathbf { H } } + \mathbf { e } _ { \psi } ^ { \prime } , } & & { \tilde { \mathbf { V } } _ { \psi } , \mathbf { S } _ { \psi } = \mathrm { M u l t i H e a d A t t n } ( \mathbf { Q } _ { \psi } , \mathbf { V } _ { \varphi } ) , } \\ & { \tilde { \mathbf { V } } _ { \psi } ^ { \prime } , \mathbf { S } _ { \psi } ^ { \prime } = \mathrm { M u l t i H e a d A t t n } ( \mathbf { Q } _ { \psi } ^ { \prime } , \mathbf { V } _ { \varphi } ) , } & & { \mathbf { V } _ { \psi } = \mathrm { F e e d F o r w a r d } ( \mathrm { C o n c a t } ( \tilde { \mathbf { V } } _ { \psi } , \tilde { \mathbf { V } } _ { \psi } ^ { \prime } ) ) . } \end{array}
+$$
+
+Here, $\mathbf { e } _ { \psi }$ and $\mathbf { e } _ { \psi } ^ { \prime }$ are the first and second argument encodings, such that $\mathbf { Q } _ { \psi }$ and $\mathbf { Q } _ { \psi } ^ { \prime }$ encode the arguments of each statement in $\Psi$ . The compatibility between paths and the arguments are computed with two MultiHeadAttns. Finally, a FeedForward is used to aggregate the selections. Its output $\mathbf { V } _ { \psi } \in \mathbb { R } ^ { K \times d }$ represents the results of all statement evaluations in $\Psi$ .
+
+Formula search: Let $\mathbf { Q } _ { f , l } , \mathbf { Q } _ { f , l } ^ { \prime } \in \mathbb { R } ^ { C \times d }$ be the learnable queries of the first and second argument of formulas at $l$ th level, and let $\mathbf { V } _ { f , 0 } = \mathbf { V } _ { \psi }$ . The formula attention is generated as
+
+$$
+\begin{array} { r l } & { \hat { \mathbf { V } } _ { f , l - 1 } = [ \mathbf { V } _ { f , l - 1 } + \mathbf { e } _ { + } , \mathbf { V } _ { f , l - 1 } + \mathbf { e } _ { - } ] , \qquad \tilde { \mathbf { V } } _ { f , l } , \mathbf { S } _ { f , l } = \mathrm { M u l t i H e a d A t t n } ( \mathbf { Q } _ { f , l } , \hat { \mathbf { V } } _ { f , l - 1 } ) , } \\ & { \tilde { \mathbf { V } } _ { f , l } ^ { \prime } , \mathbf { S } _ { f , l } ^ { \prime } = \mathrm { M u l t i H e a d A t t n } ( \mathbf { Q } _ { f , l } ^ { \prime } , \hat { \mathbf { V } } _ { f , l - 1 } ) , \quad \mathbf { V } _ { f , l } = \mathrm { F e e d F o r w a r d } ( \mathrm { C o n c a t } ( \tilde { \mathbf { V } } _ { f , l } , \tilde { \mathbf { V } } _ { f , l } ^ { \prime } ) ) . } \end{array}
+$$
+
+Here, $\mathbf { e } _ { + } , \mathbf { e } _ { - }$ are the learnable embeddings, such that $\hat { \mathbf { V } } _ { f , l - 1 }$ represents the positive and negative states of the formulas at $l - 1$ th level. Similar to the statement search, the compatibility between the logic and arguments and the previous formulas are computed with two MultiHeadAttns. And the embeddings of formulas at $l \mathrm { t h }$ level $\mathbf { V } _ { f , l }$ are aggregated by a FeedForward. Finally, let ${ \bf q } _ { o }$ be the learnable final output query and let $\mathbf { V } _ { o } { = } [ \mathbf { V } _ { f , 0 } , . . . , \mathbf { V } _ { f , L - 1 } ]$ . The output attention is computed as
+
+$$
+{ \bf v } _ { o } , { \bf s } _ { o } = \mathrm { M u l t i H e a d A t t n } ( { \bf q } _ { o } , { \bf V } _ { o } ) .
+$$
+
+# 5 STOCHASTIC TRAINING AND RULE VISUALIZATIONS
+
+The training of NLIL consists of two phases: rule generation and rule evaluation. During generation, we run Eq.(15) to obtain the attentions ${ \bf S } _ { \varphi } , { \bf S } _ { \psi } , { \bf S } _ { \psi } ^ { \prime } , { \bf S } _ { f } , { \bf S } _ { f } ^ { \prime }$ and ${ \bf s } _ { o }$ for all $P ^ { * } s$ . For the evaluation phase, we sample a mini-batch of queries $\{ \langle \mathbf { x } , P ^ { * } , \mathbf { x } ^ { \prime } , y \rangle _ { i } \} _ { i = 1 } ^ { b }$ , and evaluate the formulas using Eq.(14). Here, $y$ is the query label indicating if the triplet exists in the KB or not. We sample nonexistent queries to prevent the model from learning trivial rules that always output 1. In the experiments, these negative queries are sampled uniformly from the target query matrix $M ^ { * }$ where the entry is 0. Then the objective becomes
+
+$$
+\underset { \mathbf { w } } { \arg \operatorname* { m i n } } \frac { 1 } { b } \sum _ { i } ^ { b } \mathrm { C r o s s E n t r o p y } ( y _ { i } , \mathbf { s } _ { o } ^ { \top } \mathbf { f } _ { L } ( \mathbf { x } , \mathbf { x } ^ { \prime } ) ) .
+$$
+
+Since the attentions are generated from Eq.(15) differentiably, the loss is back-propagated through the attentions into the Transformer networks for end-to-end training.
+
+# 5.1 EXTRACTING EXPLICIT RULES
+
+During training, the results from operator calls and logic combinations are averaged via attentions. For validation and testing, we evaluate the model with the explicit FOL rules extracted from the attentions. To do this, one can view an attention vector as a categorical distribution. For example, $\mathbf { s } _ { \varphi } ^ { ( t ) }$ is such a distribution over random variables $k \in [ 1 , K ]$ . And the weighted sum is the expectation over $M _ { k }$ . Therefore, one can extract the explicit rules by sampling from the distributions (Kool et al., 2018; Yang et al., 2017).
+
+![](images/fb5a979eef1b9ab0d19b4722598f713ff025ac8a671a70606ec09397024f576c.jpg)  
+Figure 5: (a) Time (mins) for solving Even-and-Successor tasks. (-) indicates method runs out of time limit; (b) Running time for different rule lengths; (c) $\mathbb { R } \ @ 1$ for object classification with different training set size.
+
+However, since we are interested in the best rules and the attentions usually become highly concentrated on one entity after convergence. We replace the sampling with the arg max, where we get the one-hot encoding of the entity with the largest probability mass.
+
+# 6 EXPERIMENTS
+
+We first evaluate NLIL on classical ILP benchmarks and compare it with 4 state-of-the-art KB completion methods in terms of their accuracy and efficiency. Then we show NLIL is capable of learning FOL explanations for object classifiers on a large image dataset when scene-graphs are present. Though each scene-graph corresponds to a small KB, the total amount of the graphs makes it infeasible for all classical ILP methods. We show that NLIL can overcome it via efficient stochastic training. Our implementation is available at https://github.com/gblackout/NLIL.
+
+# 6.1 CLASSICAL ILP BENCHMARKS
+
+We evaluate NLIL together with two state-of-the-art differentiable ILP methods, i.e. NeuralLP (Yang et al., 2017) and ∂ILP (Evans & Grefenstette, 2018), and two structure embedding methods, TransE (Bordes et al., 2013) and RotatE (Sun et al., 2019). Detailed experiments setup is available at Appendix C.
+
+Benchmark datasets: (i) Even-and-Successor (ES) benchmark is introduced in (Evans & Grefenstette, 2018), which involves two unary predicates $\operatorname { E v e n } ( X )$ , $\operatorname { Z e r o } ( X )$ and one binary predicate ${ \mathsf { S u c c } } ( X , Y )$ . The goal is to learn FOL rules over a set of integers. The benchmark is evaluated with 10, 50 and 1K consecutive integers starting at 0; (ii) FB15K-237 is a subset of the Freebase knowledge base (Toutanova & Chen, 2015) containing general knowledge facts; (iii) WN18 (Bordes et al., 2013) is the subset of WordNet containing relations between words. Statistics of datasets are provided in Table 2.
+
+Knowledge base completion: All models are evaluated on the KB completion task. The benchmark datasets are split into train/valid/test sets. The model is tasked to predict the probability of a fact triplet (query) being present in the KB. We use Mean Reciprocal Ranks (MRR) and Hits $@ 1 0$ for evaluation metrics (see Appendix C for details).
+
+Results on Even-and-Successor benchmark are shown in Table 5a. Since the benchmark is noisefree, we only show the wall clock time for completely solving the task. As we have previously mentioned, the forward-chaining method, i.e. ∂ILP scales exponentially in the number of facts and quickly becomes infeasible for 1K entities. Thus, we skip its evaluation for other benchmarks.
+
+Results on FB15K-237 and WN18 are shown in Table. 1. Compared to NeuralLP, NLIL yields slightly higher scores. This is due to the benchmarks favor symmetric/asymmetric relations or compositions of a few relations (Sun et al., 2019), such that most valuable rules will already lie within the chain-like search space of NeuralLP. Thus the improvements gained from a larger search space with NLIL are limited. On the other hand, with the Transformer block and smaller model created for each target predicate, NLIL can achieve a similar score at least 3 times faster. Compared to the structure embedding methods, NLIL is significantly outperformed by the current state-of-the-art, i.e. RotatE, on FB15K. This is expected because NLIL searches over the symbolic space that is highly constrained. However, the learned rules are still reasonably predictive, as its performance is comparable to that of TransE.
+
+Scalability for long rules: we demonstrate that NLIL can explore longer rules efficiently. We compare the wall clock time of NeuralLP and NLIL for performing one epoch of training against different maximum rule lengths. As shown in Figure 5b, NeuralLP searches over a chain-like rule space thus scales linearly with the length, while NLIL searches over a hierarchical space thus grows in log scale. The search time for length 32 in NLIL is similar to that for length 3 in NerualLP.
+
+# 6.2 ILP ON VISUAL GENOME DATASET
+
+The ability to perform ILP efficiently extends the applications of NLIL to beyond canonical KB completion. For example in visual object detection and relation learning, supervised models can learn to generate a scene-graph (As shown in Figure 1) for each image. It consists of nodes each labeled as an object class. And each pair of objects are connected with one type of relation. The scene-graph can then be represented as a relational KB where one can perform ILP. Learning the FOL rules on such an output of a supervised model is beneficial. As it provides an alternative way of interpreting model behaviors in terms of its relations with other classifiers that are consistent across the dataset.
+
+To show this, we conduct experiments on Visual Genome dataset (Krishna et al., 2016). The original dataset is highly noisy (Zellers et al., 2018), so we use a pre-processed version available as the GQA dataset (Hudson & Manning, 2019). The scene-graphs are converted to a collection KBs, and its statistics are shown in Table 2. We filter out the predicates with less than 1500 occurrences. The processed KBs contain 213 predicates. Then we perform ILP on learning the explanations for the top 150 objects in the dataset.
+
+Table 3: $\mathbb { R } \ @ 1$ and $\mathbf { R } @ 5$ for 150 objects classification on VG.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">Visual Genome</td></tr><tr><td>R@1</td><td>R@5</td></tr><tr><td>MLP+RCNN</td><td>0.53</td><td>0.81</td></tr><tr><td>Freq</td><td>0.40</td><td>0.44</td></tr><tr><td>NLIL</td><td>0.51</td><td>0.52</td></tr></table>
+
+Quantitatively, we evaluate the learned rules on predicting the object class labels on a held-out set in terms of their $\mathbb { R } \ @ 1$ and $\mathbf { R } @ 5$ . As none of the ILP works scale to this benchmark, we compare NLIL with two supervised baselines: (i) MLP-RCNN: a MLP classifier with RCNN features of the object (available in GQA dataset) as input; and (ii) Freq: a frequency-based baseline that predicts object label by looking at the mostly occurred object class in the relation that contains the target. This method is nontrivial. As noted in (Zellers et al., 2018), a large number of triples in Visual Genome are highly predictive by knowing only the relation type and either one of the objects or subjects.
+
+Explaining objects with rules: Results are shown in Table 3. We see that the supervised method achieves the best scores, as it relies on highly informative visual features. On the other hand, NLIL achieves a comparable score on $\mathbf { R } \ @ 1$ solely relying on KBs with sparse binary labels. We note that NLIL outperforms Freq significantly. This means the FOL rules learned by NLIL are beyond the superficial correlations exhibited by the dataset. We verify this finding by showing the rules for top objects in Table 4.
+
+Induction for few-shot learning: Logic inductive learning is data-efficient and the learned rules are highly transferrable. To see this, we vary the size of the training set and compare the $\mathbf { R } \ @ 1$ scores for 3 methods. As shown in Figure 5c, the NLIL maintains a similar $\mathbf { R } \ @ 1$ score with less than $1 \%$ of the training set.
+
+# 7 CONCLUSION
+
+In this work, we propose Neural Logic Inductive Learning, a differentiable ILP framework that learns explanatory rules from data. We demonstrate that NLIL can scale to very large datasets while being able to search over complex and expressive rules. More importantly, we show that a scalable ILP method is effective in explaining decisions of supervised models, which provides an alternative perspective for inspecting the decision process of machine learning systems.
+
+# ACKNOWLEDGMENTS
+
+This project is partially supported by DARPA ASED program under FA8650-18-2-7882. We thank Ramesh Arvind3 and Hoon $\mathrm { { \dot { N } a ^ { 4 } } }$ for implementing the MLP baseline.
+
+# REFERENCES
+
+Ivana Balazevi ˇ c, Carl Allen, and Timothy M Hospedales. Tucker: Tensor factorization for knowl- ´ edge graph completion. arXiv preprint arXiv:1901.09590, 2019.
+
+Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In Advances in neural information processing systems, pp. 2787–2795, 2013.
+
+Andres Campero, Aldo Pareja, Tim Klinger, Josh Tenenbaum, and Sebastian Riedel. Logical rule induction and theory learning using neural theorem proving. arXiv preprint arXiv:1809.02193, 2018.
+
+Xinlei Chen, Li-Jia Li, Li Fei-Fei, and Abhinav Gupta. Iterative visual reasoning beyond convolutions. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 7239–7248, 2018.
+
+William W Cohen, Fan Yang, and Kathryn Rivard Mazaitis. TensorLog: Deep learning meets probabilistic DBs. July 2017.
+
+Rajarshi Das, Arvind Neelakantan, David Belanger, and Andrew McCallum. Chains of reasoning over entities, relations, and text using recurrent neural networks. arXiv preprint arXiv:1607.01426, 2016.
+
+Rajarshi Das, Shehzaad Dhuliawala, Manzil Zaheer, Luke Vilnis, Ishan Durugkar, Akshay Krishnamurthy, Alex Smola, and Andrew McCallum. Go for a walk and arrive at the answer: Reasoning over paths in knowledge bases using reinforcement learning. arXiv preprint arXiv:1711.05851, 2017.
+
+Honghua Dong, Jiayuan Mao, Tian Lin, Chong Wang, Lihong Li, and Denny Zhou. Neural logic machines. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ B1xY-hRctX.
+
+Richard Evans and Edward Grefenstette. Learning explanatory rules from noisy data. Journal of Artificial Intelligence Research, 61:1–64, 2018.
+
+Luis Galarraga, Christina Teflioudi, Katja Hose, and Fabian M Suchanek. Fast rule mining in onto- ´ logical knowledge bases with amie+. The VLDB JournalThe International Journal on Very Large Data Bases, 24(6):707–730, 2015.
+
+Matt Gardner and Tom Mitchell. Efficient and expressive knowledge base completion using subgraph feature extraction. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1488–1498, 2015.
+
+Riccardo Guidotti, Anna Monreale, Salvatore Ruggieri, Franco Turini, Fosca Giannotti, and Dino Pedreschi. A survey of methods for explaining black box models. ACM computing surveys (CSUR), 51(5):93, 2019.
+
+Kelvin Guu, John Miller, and Percy Liang. Traversing knowledge graphs in vector space. arXiv preprint arXiv:1506.01094, 2015.
+
+Vinh Thinh Ho, Daria Stepanova, Mohamed H Gad-Elrab, Evgeny Kharlamov, and Gerhard Weikum. Rule learning from knowledge graphs guided by embedding models. In International Semantic Web Conference, pp. 72–90. Springer, 2018.
+
+Drew A Hudson and Christopher D Manning. Gqa: A new dataset for real-world visual reasoning and compositional question answering. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 6700–6709, 2019.
+
+Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! arXiv preprint arXiv:1803.08475, 2018.
+
+Ranjay Krishna, Yuke Zhu, Oliver Groth, Justin Johnson, Kenji Hata, Joshua Kravitz, Stephanie Chen, Yannis Kalantidis, Li-Jia Li, David A Shamma, Michael Bernstein, and Li Fei-Fei. Visual genome: Connecting language and vision using crowdsourced dense image annotations. 2016. URL https://arxiv.org/abs/1602.07332.
+
+Ni Lao and William W Cohen. Relational retrieval using a combination of path-constrained random walks. Machine learning, 81(1):53–67, 2010.
+
+Nada Lavrac and Saso Dzeroski. Inductive logic programming. In WLP, pp. 146–160. Springer, 1994.
+
+Yankai Lin, Zhiyuan Liu, Huanbo Luan, Maosong Sun, Siwei Rao, and Song Liu. Modeling relation paths for representation learning of knowledge bases. arXiv preprint arXiv:1506.00379, 2015.
+
+Zachary C Lipton. The mythos of model interpretability. arXiv preprint arXiv:1606.03490, 2016.
+
+Pasquale Minervini, Matko Bosnjak, Tim Rocktaschel, and Sebastian Riedel. Towards neural theo-¨ rem proving at scale. arXiv preprint arXiv:1807.08204, 2018.
+
+Brent Mittelstadt, Chris Russell, and Sandra Wachter. Explaining explanations in ai. In Proceedings of the conference on fairness, accountability, and transparency, pp. 279–288. ACM, 2019.
+
+Chris Olah, Arvind Satyanarayan, Ian Johnson, Shan Carter, Ludwig Schubert, Katherine Ye, and Alexander Mordvintsev. The building blocks of interpretability. Distill, 3(3):e10, 2018.
+
+Pouya Ghiasnezhad Omran, Kewen Wang, and Zhe Wang. Scalable rule learning via learning representation. In IJCAI, pp. 2149–2155, 2018.
+
+Ali Payani and Faramarz Fekri. Inductive logic programming via differentiable deep neural logic networks. arXiv preprint arXiv:1906.03523, 2019.
+
+Marco Tulio Ribeiro, Sameer Singh, and Carlos Guestrin. Why should i trust you?: Explaining the predictions of any classifier. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 1135–1144. ACM, 2016.
+
+Tim Rocktaschel and Sebastian Riedel. End-to-end differentiable proving. In ¨ Advances in Neural Information Processing Systems, pp. 3788–3800, 2017.
+
+Richard Socher, Danqi Chen, Christopher D Manning, and Andrew Ng. Reasoning with neural tensor networks for knowledge base completion. In Advances in neural information processing systems, pp. 926–934, 2013.
+
+Zhiqing Sun, Zhi-Hong Deng, Jian-Yun Nie, and Jian Tang. Rotate: Knowledge graph embedding by relational rotation in complex space. arXiv preprint arXiv:1902.10197, 2019.
+
+Kristina Toutanova and Danqi Chen. Observed versus latent features for knowledge base and text inference. In Proceedings of the 3rd Workshop on Continuous Vector Space Models and their Compositionality, pp. 57–66, 2015.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Fan Yang, Zhilin Yang, and William W Cohen. Differentiable learning of logical rules for knowledge base reasoning. In Advances in Neural Information Processing Systems, pp. 2319–2328, 2017.
+
+Rowan Zellers, Mark Yatskar, Sam Thomson, and Yejin Choi. Neural motifs: Scene graph parsing with global context. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 5831–5840, 2018.
+
+# A RELATED WORK
+
+Inductive Logic Programming (ILP) is the task that seeks to summarize the underlying patterns shared in the data and express it as a set of logic programs (or rule/formulae) (Lavrac & Dzeroski, 1994). Traditional ILP methods such as $\mathrm { A M E + }$ (Galarraga et al., 2015) and RLvLR (Omran et al., ´ 2018) relies on explicit search-based method for rule mining with various pruning techniques. These works can scale up to very large knowledge bases. However, the algorithm complexity grows exponentially in the size of the variables and predicates involved. The acquired rules are often restricted to Horn clauses with a maximum length of less than 3, limiting the expressiveness of the rules. On the other hand, compared to the differentiable approach, traditional methods make use of hard matching and discrete logic for rule search, which lacks the tolerance for ambiguous and noisy data.
+
+The state-of-the-art differentiable forward-chaining methods focus on rule learning on predefined templates (Evans & Grefenstette, 2018; Campero et al., 2018; Ho et al., 2018), typically in the form of a Horn clause with one head predicate and two body predicates with chain-like variables, i.e.
+
+$$
+P ^ { * } ( X , X ^ { \prime } )  P _ { 1 } ( X , Y ) \land P _ { 2 } ( Y , X ^ { \prime } ) .
+$$
+
+To evaluate the rules, one starts with a background set of facts and repeatedly apply rules for every possible triple until no new facts can be deduced. Then the deduced facts are compared with a heldout ground-truth set. Rules that are learned in this approach are in first-order, i.e. data-independent and can be readily interpreted. However, the deducing phase can quickly become infeasible with a larger background set. Although ∂ILP (Evans & Grefenstette, 2018) has proposed to alleviate by performing only a fixed number of steps, works of this type could generally scale to KBs with less than 1K facts and 100 entities. On the other hand, differentiable backward-chaining methods such as NTP (Rocktaschel & Riedel, 2017) are more efficient in rule evaluation. In (Minervini et al., ¨ 2018), NTP 2.0 can scale to larges KBs such as WordNet. However, FOL rules are searched with templates, so the expressiveness is still limited.
+
+Another differentiable ILP method, i.e. Neural Logic Machine (NLM), is proposed in (Dong et al., 2019), which learns to represent logic predicates with tensorized operations. NLM is capable of both deductive and inductive learning on predicates with unknown arity. However, as a forward-chaining method, it also suffers from the scalability issue as ∂ILP. It involves a permutation operation over the tensors when performing logic deductions, making it difficult to scale to real-world KBs. On the other hand, the inductive rules learned by NLM are encoded by the network parameters implicitly, so it does not support representing the rules with explicit predicate and logic variable symbols.
+
+Multi-hop reasoning: Multi-hop reasoning methods (Guu et al., 2015; Lao & Cohen, 2010; Lin et al., 2015; Gardner & Mitchell, 2015; Das et al., 2016; Yang et al., 2017) such as NeuralLP (Yang et al., 2017) construct rule on-the-fly when given a specific query. It adopts a flexible ILP setting: instead of pre-defining templates, it assumes a chain-like Horn clause can be constructed to answer the query
+
+$$
+P ^ { * } ( X , X ^ { \prime } )  P ^ { ( 1 ) } ( X , Y _ { 1 } ) \land P ^ { ( 2 ) } ( Y _ { 1 } , Y _ { 2 } ) \land \ldots \land P ^ { ( T ) } ( Y _ { n - 1 } , X ^ { \prime } ) .
+$$
+
+And each step of the reasoning in the chain can be efficiently represented by matrix multiplication. The resulting algorithm is highly scalable compared to the forward-chaining counter-parts and can learn rules on large datasets such as FreeBase. However, this approach reasons over a single chainlike path, and the path is sampled by performing random walks that are independent on the task context (Das et al., 2017), limiting the rule expressiveness. On the other hand, the FOL rule is generated while conditioning on the specific query, making it difficult to extract rules that are globally consistent.
+
+Link prediction with relational embeddings: Besides multi-hop reasoning methods, a number of works are proposed for KB completion using learnable embeddings for KB relations. For example, In (Bordes et al., 2013; Sun et al., 2019; Balazevi ˇ c et al., 2019) it learns to map KB relations into ´ vector space and predict links with scoring functions. NTN (Socher et al., 2013), on the other hand, parameterizes each relation into a neural network. In this approach, embeddings are used for predicting links directly, thus its prediction cannot be interpreted as explicit FOL rules. This is different from that in NLIL, where predicate embeddings are used for generating data-independent rules.
+
+Table 4: Example rules learned by NLIL   
+
+<table><tr><td rowspan=1 colspan=1>Person(X) ← (Shirt(Yi) ^ Wearing(X,Yi))V(Pants(Y2) ^ Wearing(X,Y2))V(Street(Y3)^WalkingOn(X,Y3))</td></tr><tr><td rowspan=1 colspan=1>Tree(X) ← (Leaf(Yi) ∧At(Yi,X))V(SideWalk(Y2) ∧ Near(Y2,X))</td></tr><tr><td rowspan=1 colspan=1>Shirt(X) ← (Person(Yi) ^ Wearing(Yi,X)) V(Child(Y2)^Wearing(Y2,X))</td></tr><tr><td rowspan=1 colspan=1>Sky(X) ← (Clouds(Yi) ^ in(Yi,X)) V(Airplane(Y2)^Below(X,Y2))</td></tr><tr><td rowspan=1 colspan=1>Head(X)← Helmet(Yi)^Above(Y1,X)</td></tr><tr><td rowspan=1 colspan=1>Head(X) ← Wearing(Yi,Y2)^SittingOn(X,Yi)^ Hat(Y2)</td></tr><tr><td rowspan=1 colspan=1>Sign(X) ← (Number(Yi)^ On(Yi,X))V (Post(Y2) ^ On(Y2,X))V(Letter(Y3)^ In(Y3,X))</td></tr><tr><td rowspan=1 colspan=1>Sign(X) ← StreetLight(Yi) ^ On(Yi,Y2)^ On(X,Y2)</td></tr><tr><td rowspan=1 colspan=1>Ground(X) ← (Dog(Yi) ∧ On(Yi,X)) V(Grass(Y2) ^ CoveredBy(X,Y2))</td></tr><tr><td rowspan=1 colspan=1>Car(X)←Wheel(Yi)^Of(Yi,X)∧Window(Y2)∧ Of(Y2,X)</td></tr><tr><td rowspan=1 colspan=1>Sidewalk(X) ← Person(Yi) ^WalkingOn(Yi,X) ^ Street(Y2) ^ Near(X,Y2)</td></tr><tr><td rowspan=1 colspan=1>Car(X)←Wheel(Yi)^Of(Yi,X)∧Window(Y2)∧ Of(Y2,X)</td></tr><tr><td rowspan=1 colspan=1>Ear(X)←Eye(Yi)^ Of(Yi,Y2)∧ Of(X,Y2)</td></tr><tr><td rowspan=1 colspan=1>Chair(X) ← Arm(Yi) ^ In(Y,X) ^ Person(Y2)^ SittingOn(Y2,X)</td></tr></table>
+
+# B CHALLENGES IN ILP
+
+Standard ILP approaches are difficult and involve several procedures that have been proved to be NP-hard. The complexity comes from 3 levels: first, the search space for a formula is vast. The body of the entailment can be arbitrarily long and the same predicate can appear multiple times with different variables, for example, the Inside predicate in Eq.(2) appears twice. Most ILP works constrain the logic entailment to be Horn clause, i.e. the body of the entailment is a flat conjunction over literals, and the length limited within 3 for large datasets.
+
+Second, constructing formulas also involves assigning logic variables that are shared across different predicates, which we refer to as variable binding. For example, in Eq.(2), to express that a person is inside the car, we use $X$ and $Y$ to represent the region of a person and that of a car, and the same two variables are used in Inside to express their relations. Different bindings lead to different meanings. For a formula with $n$ arguments (Eq.(2) has 7), there are $\mathcal { O } ( n ^ { n } )$ possible assignments. Existing ILP works either resort to constructing formula from pre-defined templates (Evans & Grefenstette, 2018; Campero et al., 2018) or from chain-like variable reference (Yang et al., 2017), limiting the expressiveness of the learned rules.
+
+Finally, evaluating a formula candidate is expensive. A FOL rule is data-independent. To evaluate it, one needs to replace the variables with actual entities and compute its value. This is referred to as grounding or instantiation. Each variable used in a formula can be grounded independently, meaning a formula with $n$ variables can be instantiated into ${ \mathcal { O } } ( C ^ { n } )$ grounded formulas, where $C$ is the number of total entities. For example, Eq.(2) contains 3 logic variables: $X$ , $Y$ and $Z$ . To evaluate this formula, one needs to instantiate these variables into $C ^ { 3 }$ possible combinations, and check if the rule holds or not in each case. However in many domains, such as object detection, such grounding space is vast (e.g. all possible bounding boxes of an image) making the full evaluation infeasible. Many forward-chaining methods such as ∂ILP (Evans & Grefenstette, 2018) scales exponentially in the size of the grounding space, thus are limited to small scale datasets with less than 10 predicates and 1K entities.
+
+# C EXPERIMENTS
+
+Baselines: For NeuralLP, we use the official implementation at here. For ∂ILP, we use the thirdparty implementation at here. For TransE, we use the implementation at here. For RotatE, we use the official implementation at here.
+
+Table 5: Example low-accuracy rules learned by NLIL.   
+
+<table><tr><td rowspan=1 colspan=1>Bush(X)← -Tree(X)</td></tr><tr><td rowspan=1 colspan=1>Bus(X)← -(Shirt(Yi)^Wearing(Yi,X))</td></tr><tr><td rowspan=1 colspan=1>Backpack(X)← Person(Yi) ^With(Y,X)</td></tr><tr><td rowspan=1 colspan=1>Flowers(X)← Pot(Yi)^With(X,Yi)</td></tr><tr><td rowspan=1 colspan=1>Dirt(X) ← Ground(Yi) ^Near(Yi,X)</td></tr></table>
+
+Model setting: For NLIL, we create separate Transformer blocks for each target predicate. All experiments are conducted on a machine with i7-8700K, 32G RAM and one GTX1080ti. We use the embedding size $d = 3 2$ . We use 3 layers of multi-head attentions for each Transformer network. The number of attention heads are set to number of heads $= 4$ for encoder, and the first two layers of the decoder. The last layer of the decoder has one attention head to produce the final attention required for rule evaluation.
+
+For KB completion task, we set the number of operator calls $T = 2$ and formula combinations $L = 0$ , as most of the relations in those benchmarks can be recovered by symmetric/asymmetric relations or compositions of a few relations (Sun et al., 2019). Thus complex formulas are not preferred. For FB15K-237, binary predicates are grouped hierarchically into domains. To avoid unnecessary search overhead, we use the most frequent 20 predicates that share the same root domain (e.g. “award”, “location”) with the head predicate for rule body construction, which is a similar treatment as in (Yang et al., 2017). For VG dataset, we set $T = 3$ , $L = 2$ and $C = 4$ .
+
+Evaluation metrics: Following the conventions in (Yang et al., 2017; Bordes et al., 2013) we use Mean Reciprocal Ranks (MRR) and Hits $@ 1 0$ for evaluation metrics. For each query $\langle \mathbf { x } , P _ { k } , \mathbf { x } ^ { \prime } \rangle$ , the model generates a ranking list over all possible groundings of predicate $P _ { k }$ , with other groundtruth triplets filtered out. Then MRR is the average of the reciprocal rank of the queries in their corresponding lists, and Hits $@ 1 0$ is the percentage of queries that are ranked within the top 10 in the list.

parse/train/eEn8KTtJOx/eEn8KTtJOx.md

@@ -0,0 +1,398 @@
+# WANET – IMPERCEPTIBLE WARPING-BASED BACKDOOR ATTACK
+
+Anh Tuan Nguyen1,2, Anh Tuan Tran1,3   
+1VinAI Research, 2Hanoi University of Science and Technology, 3VinUniversity   
+{v.anhnt479,v.anhtt152}@vinai.io
+
+# ABSTRACT
+
+With the thriving of deep learning and the widespread practice of using pretrained networks, backdoor attacks have become an increasing security threat drawing many research interests in recent years. A third-party model can be poisoned in training to work well in normal conditions but behave maliciously when a trigger pattern appears. However, the existing backdoor attacks are all built on noise perturbation triggers, making them noticeable to humans. In this paper, we instead propose using warping-based triggers. The proposed backdoor outperforms the previous methods in a human inspection test by a wide margin, proving its stealthiness. To make such models undetectable by machine defenders, we propose a novel training mode, called the “noise” mode. The trained networks successfully attack and bypass the state of the art defense methods on standard classification datasets, including MNIST, CIFAR-10, GTSRB, and CelebA. Behavior analyses show that our backdoors are transparent to network inspection, further proving this novel attack mechanism’s efficiency. Our code is publicly available at https://github.com/VinAIResearch/ Warping-based_Backdoor_Attack-release.
+
+# 1 INTRODUCTION
+
+Deep learning models are essential in many modern systems due to their superior performance compared to classical methods. Most state-of-the-art models, however, require expensive hardware, huge training data, and long training time. Hence, instead of training the models from scratch, it is a common practice to use pre-trained networks provided by third-parties these days. This poses a serious security threat of backdoor attack (Gu et al., 2017). A backdoor model is a network poisoned either at training or finetuning. It can work as a genuine model in the normal condition. However, when a specific trigger appears in the input, the model will act maliciously, as designed by the attacker. Backdoor attack can occur in various tasks, including image recognition (Chen et al., 2017), speech recognition (Liu et al., 2018b), natural language processing (Dai et al., 2019), and reinforcement learning (Hamon et al., 2020). In this paper, we will focus on image classification, the most popular attacking target with possible fatal consequences (e.g., for self-driving car).
+
+Since introduced, backdoor attack has drawn a lot of research interests (Chen et al., 2017; Liu et al., 2018b; Salem et al., 2020; Nguyen & Tran, 2020). In most of these works, trigger patterns are based on patch perturbation or image blending. Recent papers have proposed novel patterns such as sinusoidal strips (Barni et al., 2019), and reflectance (Liu et al., 2020). These backdoor triggers, however, are unnatural and can be easily spotted by humans.
+
+We believe that the added content, such as noise, strips, or reflectance, causes the backdoor samples generated by the previous methods strikingly detectable. Instead, we propose to use image warping that can deform but preserve image content. We also found that humans are not good at recognizing subtle image warping, while machines are excellent in this task.
+
+Hence, in this paper, we design a novel, simple, but effective backdoor attack based on image warping called WaNet. We use a small and smooth warping field in generating backdoor images, making the modification unnoticeable, as illustrated in Fig. 1. Our backdoor images are natural and hard to be distinguished from the genuine examples, confirmed by our user study described in Sec. 4.3.
+
+![](images/ff3c3082a77419286dd5c7d0a7f2e6003a465d0672b89d00b49eab1053d420b0.jpg)  
+Figure 1: Comparison between backdoor examples generated by our method and by the previous backdoor attacks. Given the original image (leftmost), we generate the corresponding backdoor images using patch-based attacks (Gu et al., 2017; Liu et al., 2018b), blending-based attack (Chen et al., 2017), SIG (Barni et al., 2019), ReFool (Liu et al., 2020), and our method. For each method, we show the image (top), the magnified $( \times 2 )$ residual map (bottom). The images generated from the previous attacks are unnatural and can be detected by humans. In constrast, ours is almost identical to the original image, and the difference is unnoticeable.
+
+To obtain a backdoor model, we first follow the common training procedure by poisoning a part of training data with a fixed ratio of $\rho _ { a } \in ( 0 , 1 )$ . While the trained networks provide high clean and attack accuracy, we found that they “cheated” by learning pixel-wise artifacts instead of the warping itself. It makes them easy to be caught by a popular backdoor defense Neural Cleanse. Instead, we add another mode in training, called “noise mode”, to enforce the models to learn only the predefined backdoor warp. This novel training scheme produces satisfactory models that are both effective and stealthy.
+
+Our attack method achieves invisibility without sacrificing accuracy. It performs similarly to stateof-the-art backdoor methods in terms of clean and attack accuracy, verified on common benchmarks such as MNIST, CIFAR-10, GTSRB, and CelebA. Our attack is also undetectable by various backdoor defense mechanisms; none of existing algorithms can recognize or mitigate our backdoor. This is because the attack mechanism of our method is drastically different from any existing attack, breaking the assumptions of all defense methods.
+
+Finally, we demonstrate that our novel backdoor can be a practical threat by deploying it for physical attacks. We tested the backdoor classifier with camera-captured images of physical screens. Despite image quality degradation via extreme capturing conditions, our backdoor is well-preserved, and the attack accuracy stays near $100 \%$ .
+
+In short, we introduce a novel backdoor attack via image warping. To train such a model, we extend the standard backdoor training scheme by introducing a “noise” training mode. The attack is effective, and the backdoor is imperceptible by both humans and computational defense mechanisms. It can be deployed for physical attacks, creating a practical threat to deep-learning-based systems 1.
+
+# 2 BACKGROUND
+
+# 2.1 THREAT MODEL
+
+Backdoor attacks are techniques of poisoning a system to have a hidden destructive functionality. The poisoned system can work genuinely on clean inputs but misbehave when a specific trigger pattern appears. In the attack mode for image classification, backdoor models can return a predefined target label, normally incorrect, regardless of image content. It allows the attacker to gain illegal benefits. For example, a backdoor face authentication system may allow the attacker to access whenever he puts a specific sticker on the face.
+
+Backdoors can be injected into the deep model at any stage. We consider model poisoning at training since it is the most used threat model. The attacker has total control over the training process and maliciously alters data for his attack purposes. The poisoned model is then delivered to customers to deploy as-is. In our proposed attack, the attacker selects a fixed warping field and uses it to generate all the backdoor images in training and in testing-time attacks.
+
+# 2.2 PREVIOUS BACKDOOR ATTACKS
+
+We focus on backdoor attacks on image classification. The target network is trained for a classification task $f : \mathbb { X } \to \mathbb { C }$ , where $\mathbb { X }$ is an image domain and $\mathbb { C } = \operatorname { \bar { \{ } c _ { 1 } , }  c _ { 2 } , . . . , c _ { M } \}$ is a set of $M$ target classes. When poisoning $f$ , we enforce it to learn an injection function $\boldsymbol { B }$ , a target label function $c$ , and alter the network behaviour so that:
+
+$$
+f ( \pmb { x } ) = y , \quad f ( \pmb { B } ( \pmb { x } ) ) = c ( y )
+$$
+
+for any pair of clean image $\pmb { x } \in \mathbb { X }$ and the corresponding label $y \in \mathbb { C }$
+
+The earliest backdoor attack was BadNets (Gu et al., 2017). The authors suggested to poison a portion of training data by replacing each clean data pair $( { \pmb x } , y )$ with the corresponding poisoned pair $( B ( { \pmb x } ) , c ( { \pmb y } ) )$ . The injection function $\boldsymbol { B }$ simply replaces a fixed patch of the input image by a predefined trigger pattern. As for the target label function $c ( y )$ , the authors proposed two tests: (1) all-to-one with a constant target label $c ( y ) = { \hat { c } }$ and (2) all-to-all with $c ( y ) = y + 1$ .
+
+After BadNets, many variants of backdoor attacks have been introduced. These approaches focus on changing either the backdoor injection process or the injection function $\boldsymbol { B }$ .
+
+As for the backdoor injection process, Liu et al. (2018b) proposed to inject backdoor into clean models via fine-tuning instead of the training stage. Yao et al. (2019) suggested hiding backdoor inside latent neurons for transfer learning. Many recent studies (Turner et al., 2019; Barni et al., 2019; Liu et al., 2020), injected backdoor only on samples with unchanged labels, i.e., the target $c ( y )$ is the same as the ground-truth label $y$ , to dodge label inspection by humans.
+
+In this paper, we focus on the development of a good injection function $\boldsymbol { B }$ . Most of the popular attack methods rely on fixed patch-based triggers. Chen et al. (2017) used image blending to embed the trigger into the input image, and Nguyen & Tran (2020) extended it to be input-aware. Salem et al. (2020) varied the patch-based trigger locations and patterns to make it “dynamic”. Barni et al. (2019) employed sinusoidal strips as the trigger alongside the clean-label strategy. Lately, Liu et al. (2020) proposed to disguise backdoor triggers as reflectance to make the poisoned images look natural. The backdoor images generated by these attacks, however, are easy to be spotted by humans. We instead propose an “invisible” backdoor that is imperceptible by even sharp-eyed people.
+
+# 2.3 BACKDOOR DEFENSE METHODS
+
+As the threat of backdoor attacks becomes more apparent, backdoor defense research is emerging. Based on usage scenarios, we can classify them into three groups: training defense, model defense, and testing-time defense.
+
+Training defense assumes the defender has control over the training process, and the adversary attacks by providing infected training data (Tran et al., 2018). This assumption, however, does not match our threat model, where the already-trained backdoor model is provided by a third party. This mechanism is not applicable to our situation and will not be considered further in this paper.
+
+Model defenses aim to verify or mitigate the provided model before deployment. Fine-Pruning (Liu et al., 2018a) suggested to prune the dormant neurons, defined by analyses on a clean image set, to mitigate the backdoor if present. Neural Cleanse (Wang et al., 2019) was the first work that could detect backdoor models. It optimized a patch-based trigger candidate for each target label, then detected if any candidate was abnormally smaller than the others as a backdoor indicator. ABS (Liu et al., 2019) scanned the neurons and generated trigger candidates by reverse engineering. Cheng et al. (2019) used GradCam (Selvaraju et al., 2017) to analyze the network behavior on a clean input image with and without the synthesized trigger to detect anomalies. Zhao et al. (2019) applied mode connectivity to effectively mitigate backdoor while keeping acceptable performance. Lately, Kolouri et al. (2020) introduced universal litmus patterns that can be fed to the network to detect backdoor.
+
+Unlike model defense, testing-time defenses inspect models after deployment with the presence of input images. It focuses on verifying if the provided image is poisoned and how to mitigate it. STRIP (Gao et al., 2019) exploited the persistent outcome of the backdoor image under perturbations for detection. In contrast, Neo (Udeshi et al., 2019) searched for the candidate trigger patches where region blocking changed the predicted outputs. Recently, Doan et al. (2019) used GradCam inspection to detect potential backdoor locations. In all these methods, the trigger candidates were then verified by being injected into a set of clean images.
+
+A common assumption in all previous defense methods is that the backdoor triggers are image patches. We instead propose a novel attack mechanism based on image warping, undermining the foundation of these methods.
+
+# 2.4 ELASTIC IMAGE WARPING
+
+Image warping is a basic image processing technique that deforms an image by applying the geometric transformation. The transformation can be affine, projective, elastic, or non-elastic. In this work, we propose to use elastic image warping given its advantages over the others: (1) Affine and projective transformations are naturally introduced to clean images via the image capturing process. If we apply these transformations to these images, the transformed images can be identical to other clean images that are of the same scenes but captured at different viewpoints. Hence, these transformations are not suitable to generate backdoor examples, particularly in physical attacks. (2) Elastic transformation still generates natural outputs while non-elastic one does not.
+
+The most popular elastic warping technique is Thin-Plate Splines (TPS) (Duchon, 1977). TPS can interpolate a smooth warping field to transform the entire image given a set of control points with known original and target 2D coordinates. TPS was adopted in Spatial Transformer Networks (Jaderberg et al., 2015), the first deep learning study incorporating differential image warping.
+
+We believe that elastic image warping can be utilized to generate invisible backdoor triggers. Unlike previous attack methods that introduce extra and independent information to an input image, elastic image warping only manipulates existing pixels of the image. Humans, while being excellent in spotting incongruent part of an image, are bad at recognizing small geometric transformations.
+
+# 3 WARPING-BASED BACKDOOR ATTACK
+
+We now describe our novel backdoor attack method WaNet, which stand for Warping-based poisoned Networks. WaNet are designed to be stealthy to both machine and human inspections.
+
+# 3.1 OVERVIEW
+
+Recall that a classification network is a function $f : \mathbb { X } \to \mathbb { C }$ , in which $\mathbb { X }$ is an input image domain and $\mathbb { C }$ is a set of target classes. To train $f$ , a training dataset $\mathbb { S } = \{ ( \mathbf { x } _ { i } , y _ { i } ) | \mathbf { x } _ { i } \in \mathbb { X } , \mathbf { \bar { y } } _ { i } \in \mathbb { C } , \bar { i } = \overline { { 1 , N } } \}$ is provided. We follow the training scheme of BadNets to poison a subset of $\mathbb { S }$ with ratio $\rho _ { a }$ for backdoor training. Each clean pair $( { \pmb x } , y )$ will be replaced by a backdoor pair $( B ( { \pmb x } ) , c ( { \pmb y } ) )$ , in which $\boldsymbol { B }$ is the backdoor injection function and $c ( y )$ is the target label function.
+
+Our main focus is to redesign the injection function $\boldsymbol { B }$ based on image warping. We construct $\boldsymbol { B }$ using a warping function $\mathcal { W }$ and a predefined warping field $M$ :
+
+$$
+\ B ( \pmb { x } ) = \mathscr { W } ( \pmb { x } , \pmb { M } ) .
+$$
+
+$M$ acts like a motion field; it defines the relative sampling location of backward warping for each point in the target image. $\mathcal { W }$ allows a floating-point warping field as input. When a sampling pixel falls on non-integer 2D coordinates, it will be bi-linear interpolated. To implement $\mathcal { W }$ , we rely on the public API grid sample provided by PyTorch. However, this API inputs a grid of normalized absolute 2D coordinates of the sampling points. To use that API, we first sum $M$ with an identity sampling grid, then normalize to $[ - 1 , 1 ]$ to get the required grid input.
+
+# 3.2 WARPING FIELD GENERATION
+
+The warping field $M$ is a crucial component; it must guarantee that the warped images are both natural and effective for attacking purposes. Hence, $M$ are desired to satisfy the following properties:
+
+• Small: $M$ should be small, to be unnoticeable to humans,
+
+![](images/81132bcaa7c20024d7ad25d9b48489f426beb6a86cbc53a6818d3cb183f3fe7e.jpg)  
+Figure 2: Process of creating the warping field $M$ and using it to generate poisoned images.
+
+![](images/7e29ff05e3b5688eba7a923ac82091bbc493f7a1cfef1eae1733fbd455b6f02a.jpg)  
+Figure 3: Effect of different hyper-parameters on the warping result. For each warped image, we show the image (top), the magnified $( \times 2 )$ residual map (bottom). The PSNR and LPIPS (Zhang et al., 2018) scores are computed at resolution $2 2 4 \times 2 2 4$ .
+
+• Elastic: $M$ should be elastic, i.e., smooth and non-flat, to generate natural looking images, • Within image boundary: $M$ should not exceed the image boundary, to avoid creating suspicious black/plain outer area.
+
+To get such a warping field, we borrow the idea of using control points from TPS but simplify the interpolation method. The process of generating the desired warp is illustrated by Fig. 2 and is described in the following subsections.
+
+Selecting the control grid We first select the control points. For simplicity, we pick the target points on a uniform grid of size $k \times k$ over the entire image. Their backward warping field is denoted as $\boldsymbol { P } \in \mathbb { R } ^ { k \times k \times 2 }$ . We use a parameter $s$ to define the strength of $_ { r }$ and generate $_ { r }$ as following:
+
+$$
+P = \psi ( r a n d _ { [ - 1 , 1 ] } ( k , k , 2 ) ) \times s
+$$
+
+in which $r a n d _ { [ - 1 , 1 ] } ( . . . )$ is a function returning random tensor with the input shape and element value in the range $[ - 1 , 1 ]$ and $\psi$ is a normalization function. In this paper, we normalize the tensor elements by their mean absolute value:
+
+$$
+\psi ( A ) = { \frac { A } { { \frac { 1 } { s i z e ( A ) } } \sum _ { a _ { i } \in A } \left| a _ { i } \right| } }
+$$
+
+Upsampling From the control points, we interpolate the warping field of the entire image. Since these points are in a uniform grid covering the entire image, instead of using a complex spline-based interpolation like in TPS, we can simply apply bicubic interpolation. We denote the output of this step as $M _ { 0 } = \uparrow P \in \mathbb { R } ^ { h \times w \times 2 }$ , with $h$ and $w$ being the image height and width respectively.
+
+Clipping Finally, we apply a clipping function $\phi$ so that the sampling points do not fall outside of the image border. The process of generating $M$ can be summarized by the equation:
+
+$$
+{ \cal M } = \phi ( \uparrow ( \psi ( r a n d _ { [ - 1 , 1 ] } ( k , k , 2 ) ) \times s ) ) .
+$$
+
+We investigate the effect of the hyper-parameters $k$ and $s$ qualitatively in Fig. 3. The warping effect is almost invisible when $k < 6$ and $s < 0 . 7 5$ .
+
+# 3.3 RUNNING MODES
+
+After computing the warping field $M$ , we can train WaNet with with two modes, clean and attack, as the standard protocol. However, the models trained by that algorithm, while still achieving high
+
+![](images/d3ed2c75ea36444996fc393d65dbbcf12766b4c659f7673cc736ef40f18809b7.jpg)  
+Figure 4: Training pipeline with three running modes.
+
+![](images/ca04708b4a2d8b46d98f2e9c0480cb1c70f223fc550803c2276acec1d6ac343b.jpg)
+
+accuracy in both clean and attack tests, tend to learn pixel-level artifacts instead of the warping. They are, therefore, easily exposed by a backdoor defense method such as Neural Cleanse. We will discuss more details in the ablation studies in Section 4.6.
+
+To resolve this problem, we propose a novel training mode alongside the clean and attack mode, called noise mode. The idea is simple: when applying a random warping field $M ^ { \prime } \ne M$ , the network should not trigger the backdoor but return the correct class prediction.
+
+Fig. 4 illustrates three running modes in our training pipelines. We first select the backdoor probability $\rho _ { a } \in ( 0 , 1 )$ and the noise probability $\rho _ { n } \in ( 0 , 1 )$ such that $\rho _ { a } + \rho _ { n } < 1$ . Then, for each clean input $( { \pmb x } , y )$ , we randomly select one of three modes and alter that pair accordingly:
+
+$$
+( \pmb { x } , y ) \mapsto \left\{ \begin{array} { l l } { ( \pmb { x } , y ) } & { \mathrm { w i t h ~ p r o b a b i l i t y ~ } 1 - \rho _ { a } - \rho _ { n } } \\ { ( \mathcal { W } ( \pmb { x } , \pmb { M } ) , c ( y ) ) } & { \mathrm { w i t h ~ p r o b a b i l i t y ~ } \rho _ { a } } \\ { ( \mathcal { W } ( \pmb { x } , \pmb { M } + r a n d _ { [ - 1 , 1 ] } ( h , w , 2 ) ) , y ) } & { \mathrm { w i t h ~ p r o b a b i l i t y ~ } \rho _ { n } } \end{array} \right.
+$$
+
+Note that with the noise mode, instead of using a totally random warping field, we form it by adding Gaussian noise to $M$ for a more effective training. The modified training set is then used to train $f$ .
+
+# 4 EXPERIMENTS
+
+# 4.1 EXPERIMENTAL SETUP
+
+Following the previous backdoor attack papers, we performed experiments on four datasets: MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky et al., 2009), GTSRB (Stallkamp et al., 2012) and CelebA (Liu et al., 2015). Note that CelebA dataset has annotations for 40 independent binary attributes, which is not suitable for multi-class classification. Therefore, we follow the configuration suggested by Salem et al. (2020) to select the top three most balanced attributes, including Heavy Makeup, Mouth Slightly Open, and Smiling, then concatenate them to create eight classification classes. Their detail information are shown in Table 1. To build the classifier $f$ for the color image datasets, we used Pre-activation Resnet-18 (He et al., 2016) for the CIFAR-10 and GTSRB datasets as suggested by Kang (2020), and Resnet-18 for the CelebA dataset. As for the grayscale dataset MNIST, we defined a simple network structure as reported in Table 1.
+
+We trained the networks using the SGD optimizer. The initial learning rate was 0.01, which was reduced by a factor of 10 after each 100 training epochs. The networks were trained until convergence. We used $k = 4$ , $s = 0 . 5$ , $\rho _ { a } = 0 . 1$ , and $\rho _ { n } = 0 . 2$ .
+
+Table 1: Datasets and the classifiers used in our experiments. Each ConvBlock consists of a $3 \times 3$ convolution (stride $^ { \cdot = 2 }$ ), a BatchNorm, and a ReLU layer.
+
+![](images/9dd4edb918d24b7d2e5819528c233a4e8a5f2da0fa8f130159fec55c5486ad46.jpg)  
+Figure 6: Human inspection tests: (a) Success fooling rates of each backdoor method, (b) The most distinguishable cases from WaNet.
+
+# 4.2 ATTACK EXPERIMENTS
+
+We trained and tested the backdoor models in all-to-one configuration, i.e., $c ( y ) = \hat { c } \forall y$ . The accuracy values in clean mode, attack mode, and the noise mode are reported in Fig. 5a. As can be seen, with clean images, the networks could correctly classify them like any benign models, with accuracy near $100 \%$ on MNIST/GTSRB, $9 4 . 1 5 \%$ on CIFAR-10, and $7 9 . 7 7 \%$ on CelebA. When applying the pre-defined image warping, the attack success rate was near $100 \%$ on all datasets. However, when using a random warping, the classifiers still recognized the true image class with a similar accuracy as in the clean mode. This result is impressive given the fact that the poisoned images look almost identical to the original, as can be seen in Fig. 5b.
+
+To evaluate our method’s robustness in real-life scenarios, we also tested if backdoor images would still be misclassified even when being distorted by the capturing process. We showed 50 clean and 50 backdoor images on a screen and recaptured them using a phone camera. Our model still worked well on recaptured images, obtaining $98 \%$ clean accuracy and $96 \%$ attack success rate. Fig. 5c displays an example of our test. The clean image was recognized correctly as “automobile”, while the look-a-like backdoor image was recognized as the “airplane” attack class.
+
+# 4.3 HUMAN INSPECTION
+
+To examine the realisticity of our backdoor and the previous methods, we created user studies with human inspection. First, we randomly selected 25 images from the GTSRB dataset. Second, for each backdoor injection function, we created the corresponding 25 backdoor images and mixed them with the original to obtain a set of 50 images. Finally, we asked 40 people to classify whether each image was genuine, collecting 2000 answers per method. The participants were trained about the mechanism and characteristics of the attack before answering the questions.
+
+We collected the answers and reported the percentage of incorrect answers as the success fooling rates in Fig. 6a. Note that when the backdoor examples are more indistinguishable from the clean ones, the testers will find it harder to decide an image is clean or poisoned. Hence, better backdoor methods led to higher fooling rates on not only backdoor inputs but also on clean ones. The rates from previous methods are low, with maximum $7 . 7 \%$ on all inputs, implying that they are obvious to humans to detect. In contrast, our rate is $28 \%$ , four times their best number. It confirms that WaNet is stealthy and hard to detect, even with trained people.
+
+Although our backdoor images are natural-looking, some of them have subtle properties that can be detected by trained testers. We provide two of the most detected backdoor examples from WaNet in Fig. 6b. In the first case, the circle sign is not entirely round. In the second case, the right edge of the traffic sign is slightly curved. Although these conditions can be found on real-life traffic signs, they are not common in the testing dataset GTSRB. These images are of the minority, and our fooling rate on backdoor images is $3 8 . 6 \%$ , not far away from the rate of $50 \%$ in random selection.
+
+![](images/f7f9082c0ff5c9c114493eea47e6bfd11a3b49ea7cbbcaab4d630a51fb8631cd.jpg)  
+Figure 7: Experiments on verifying WaNet by the state-of-the-art defense and visualization methods.
+
+# 4.4 DEFENSE EXPERIMENTS
+
+We will now test the trained models against the popular backdoor defense mechanisms, including Neural Cleanse, Fine-Prunning (Model defenses), and STRIPS (Testing-time defense).
+
+Neural Cleanse (Wang et al., 2019) is a model-defense method based on the pattern optimization approach. It assumes that the backdoor is patch-based. For each class label, Neural Cleanse computes the optimal patch pattern to convert any clean input to that target label. It then checks if any label has a significantly smaller pattern as a sign of backdoor. Neural Cleanse quantifies it by the Anomaly Index metric with the clean/backdoor threshold $\tau = 2$ . We ran Neural Cleanse over our WaNet models and report the numbers in Fig. 7c. WaNet passed the test on all datasets; its scores are even smaller than the clean model ones on MNIST and CIFAR-10. We can explain it by the fact that our backdoor relies on warping, a different mechanism compared with patch-based blending.
+
+Fine-Pruning (Liu et al., 2018a), instead, focuses on neuron analyses. Given a specific layer, it analyzes the neuron responses on a set of clean images and detects the dormant neurons, assuming they are more likely to tie to the backdoor. These neurons are then gradually pruned to mitigate the backdoor. We tested Fine-Pruning on our models and plotting the network accuracy, either clean or attack, with respect to the number of neurons pruned in Fig. 7a. On all datasets, at no point is the clean accuracy considerably higher than the attack one, making backdoor mitigation impossible.
+
+STRIP (Gao et al., 2019) is a representative of the testing-time defense approach. It examines the model with the presence of the input image. STRIP works by perturbing the input image through a set of clean images from different classes and raising the alarm if the prediction is persistent, indicating by low entropy. With WaNet, the perturbation operation of STRIP will modify the image content and break the backdoor warping if present. Hence, WaNet behaves like genuine models, with similar entropy ranges, as shown in Fig. 7b.
+
+# 4.5 NETWORK INSPECTION
+
+Visualization tools, such as GradCam (Selvaraju et al., 2017), are helpful in inspecting network behaviors. Patch-based backdoor methods can be exposed easily due to the use of small trigger regions, as pointed out by Cheng et al. (2019); Doan et al. (2019). Our attack method is based on the warping on the entire image, so it is undetectable by this algorithm. We visualize activation based on the label that has the highest prediction score in Fig. 7d. With clean models, that label is for the correct class label. With WaNet and backdoor inputs, it is the backdoor label $\hat { c }$ . As can be seen, the visualization heatmaps of WaNet look like the ones from any clean model.
+
+![](images/902edff74c83bc38bd176b15e3f183a6000bf9a3c5c93a60ca8a5a9523d32ea0.jpg)  
+Figure 8: Ablation studies on CIFAR-10 dataset: (a) Role of the noise mode training, (b,c) Network performance when changing warping hyper-parameters.
+
+# 4.6 ABLATION STUDIES
+
+Role of the noise mode Without the noise mode, we could still train a backdoor model with similar clean and attack accuracy. However, these models failed the defense test with Neural Cleanse as shown in Fig. 9, and the optimized trigger patterns revealed their true behavior.
+
+![](images/cd132370d6ae5f49b8a4e76bbc6c4973500ffc7177fc53c933bb82191fa21597.jpg)  
+Figure 9: Networks’ performance against Neural Cleanse with and without noise mode.
+
+Fig. 8a displays the trigger patterns optimized by Neural Cleanse for the attacking class “airplane” on CIFAR-10. With the clean model, this pattern has an airplane-like shape, and it is big enough to rewrite image content given any input. With our model trained without noise mode, the optimized pattern just consists of scattered points. This pattern is remarkably smaller, making the model caught by Neural Cleanse. It reveals that the model did not learn the specific backdoor warping; instead, it remembered the pixel-wise artifacts. By adding the noise training mode, our model no longer relies on those artifacts, and the optimized pattern looks similar to the clean model’s one.
+
+Other hyper-parameters We investigated the effect of the warping hyper-parameters, including the strength $s$ and the grid size $k$ . Fig. 8b and 8c show the clean, attack, and noise mode accuracy of our network on the CIFAR-10 dataset when changing each of these parameters. When $k$ or $s$ is small, the backdoor images are similar to the clean ones. However, since they are a minority $( \rho _ { a } = 0 . 1 )$ , the network would treat them like data with noisy labels in those scenarios. Hence, clean and noise accuracies are stable across configurations. In contrast, backdoor accuracy suffers on the left side of the plots. It gradually increases when $s$ or $k$ is small, then saturates and stays near $100 \%$ .
+
+# 5 CONCLUSION AND FUTURE WORKS
+
+This paper introduces a novel backdoor attack method that generates backdoor images via subtle image warping. The backdoor images are proved to be natural and undetectable by humans. We incorporate in training a novel “noise” mode, making it stealthy and pass all the known defense methods. It opens a new domain of attack mechanism and encourages future defense research.
+
+# REFERENCES
+
+Mauro Barni, Kassem Kallas, and Benedetta Tondi. A new backdoor attack in cnns by training set corruption without label poisoning. In 2019 IEEE International Conference on Image Processing (ICIP), pp. 101–105. IEEE, 2019.
+
+Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song. Targeted backdoor attacks on deep learning systems using data poisoning. arXiv preprint arXiv:1712.05526, 2017.
+
+Hao Cheng, Kaidi Xu, Sijia Liu, Pin-Yu Chen, Pu Zhao, and Xue Lin. Defending against Backdoor Attack on Deep Neural Networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining Workshop, 2019.
+
+Jiazhu Dai, Chuanshuai Chen, and Yufeng Li. A backdoor attack against lstm-based text classification systems. IEEE Access, 7:138872–138878, 2019.
+
+Bao Gia Doan, Ehsan Abbasnejad, and Damith C. Ranasinghe. Februus: Input Purification Defense Against Trojan Attacks on Deep Neural Network Systems. arXiv, Aug 2019. URL https: //arxiv.org/abs/1908.03369.
+
+Jean Duchon. Splines minimizing rotation-invariant semi-norms in sobolev spaces. In Constructive theory of functions of several variables, pp. 85–100. Springer, 1977.
+
+Yansong Gao, Change Xu, Derui Wang, Shiping Chen, Damith C Ranasinghe, and Surya Nepal. Strip: A defence against trojan attacks on deep neural networks. In Proceedings of the 35th Annual Computer Security Applications Conference, pp. 113–125, 2019.
+
+Tianyu Gu, Brendan Dolan-Gavitt, and Siddharth Garg. Badnets: Identifying vulnerabilities in the machine learning model supply chain. In Proceedings of Machine Learning and Computer Security Workshop, 2017.
+
+Ronan Hamon, Henrik Junklewitz, and Ignacio Sanchez. Robustness and explainability of artificial intelligence. Publications Office of the European Union, 2020.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016.
+
+Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in neural information processing systems, pp. 2017–2025, 2015.
+
+Liu Kang. pytorch-cifar, May 2020. URL https://github.com/kuangliu/ pytorch-cifar. [Online; accessed 4. Jun. 2020].
+
+Soheil Kolouri, Aniruddha Saha, Hamed Pirsiavash, and Heiko Hoffmann. Universal litmus patterns: Revealing backdoor attacks in cnns. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 301–310, 2020.
+
+Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009.
+
+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.
+
+Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg. Fine-pruning: Defending against backdooring attacks on deep neural networks. In Proceedings of International Symposium on Research in Attacks, Intrusions, and Defenses, 2018a.
+
+Yingqi Liu, Shiqing Ma, Yousra Aafer, Wen-Chuan Lee, Juan Zhai, Weihang Wang, and Xiangyu Zhang. Trojaning attack on neural networks. In Proceedings of Network and Distributed System Security Symposium, 2018b.
+
+Yingqi Liu, Wen-Chuan Lee, Guanhong Tao, Shiqing Ma, Yousra Aafer, and Xiangyu Zhang. Abs: Scanning neural networks for back-doors by artificial brain stimulation. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, pp. 1265–1282, 2019.
+
+Yunfei Liu, Xingjun Ma, James Bailey, and Feng Lu. Reflection backdoor: A natural backdoor attack on deep neural networks. 2020.
+
+Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015.
+
+Tuan Anh Nguyen and Anh Tran. Input-aware dynamic backdoor attack. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 3454–3464. Curran Associates, Inc., 2020. URL https://proceedings.neurips.cc/paper/2020/file/ 234e691320c0ad5b45ee3c96d0d7b8f8-Paper.pdf.
+
+Ahmed Salem, Rui Wen, Michael Backes, Shiqing Ma, and Yang Zhang. Dynamic backdoor attacks against machine learning models. arXiv preprint arXiv:2003.03675, 2020.
+
+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.
+
+Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural networks, 32:323–332, 2012.
+
+Brandon Tran, Jerry Li, and Aleksander Madry. Spectral signatures in backdoor attacks. In Proceedings of Advances in Neural Information Processing Systems, 2018.
+
+Alexander Turner, Dimitris Tsipras, and Aleksander Madry. Clean-label backdoor attacks. https://people.csail.mit.edu/madry/lab/, 2019.
+
+Sakshi Udeshi, Shanshan Peng, Gerald Woo, Lionell Loh, Louth Rawshan, and Sudipta Chattopadhyay. Model agnostic defence against backdoor attacks in machine learning. arXiv preprint arXiv:1908.02203, 2019.
+
+Bolun Wang, Yuanshun Yao, Shawn Shan, Huiying Li, Bimal Viswanath, Haitao Zheng, and Ben Y Zhao. Neural cleanse: Identifying and mitigating backdoor attacks in neural networks. In Proceedings of 40th IEEE Symposium on Security and Privacy, 2019.
+
+Yuanshun Yao, Huiying Li, Haitao Zheng, and Ben Y Zhao. Latent backdoor attacks on deep neural networks. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, pp. 2041–2055, 2019.
+
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018.
+
+Pu Zhao, Pin-Yu Chen, Payel Das, Karthikeyan Natesan Ramamurthy, and Xue Lin. Bridging mode connectivity in loss landscapes and adversarial robustness. In International Conference on Learning Representations, 2019.
+
+# A APPENDIX
+
+# A.1 SYSTEM DETAILS
+
+A.1.1 DATASETS
+
+We used 3 standard datasets, from simple to more complex ones, to conduct our experiments. As the datasets are all used in previous related works, our results would be more comparable and reliable.
+
+MNIST
+
+The dataset (LeCun et al., 1998) is a subset of the larger dataset available from the National Institute of Technology (NIST). This dataset consists of 70,000 grayscale, $2 8 \times 2 8$ images, divided into a training set of 60,000 images and a test set of 10,000 images. Original dataset could be found at http://yann.lecun.com/exdb/mnist/.
+
+We applied random cropping and random rotation as data augmentation for the training process.   
+During the evaluation stage, no augmentation is applied.
+
+# CIFAR10
+
+The dataset was introduced the first time by Krizhevsky et al. (2009). It is a labeled subset of the 80-millions-tiny-images dataset, collected by Alex Krizhevsky, Vinod Nair and Geoffrey Hinton, consists of 60,000 color images at the resolution of $3 2 \times 3 2$ . The dataset contains 10 classes, with 6,000 images per one. It is divided into two subsets: a training set of 50,000 images and a test set of 10,000 images. The data set is public and avalable at https://www.cs.toronto.edu/ ˜kriz/cifar.html.
+
+During training stage, random crop, random rotation and random horizontal flip were applied as data augmentation. No augmentation was added at the evaluation stage.
+
+# GTSRB
+
+The German Traffic Sign Recognition Benchmark - the GTSRB (Stallkamp et al. (2012)) is used as an official dataset for the challenge held at the International Joint Conference on Neural Network (IJCNN) 2011. This dataset consists of 60,000 images with 43 classes and the resolution varying from $3 2 \times 3 2$ to $2 5 0 \times 2 5 0$ . It is divided into a training set of 39,209 images and a test set of 12,630. The dataset could be found at http://benchmark.ini.rub.de/?section $=$ gtsrb&subsection $=$ dataset.
+
+Input images were all resized into $3 2 \times 3 2$ pixels, then applied random crop and random rotation at the training stage. No augmentation was used at the evaluation stage.
+
+# CelebA
+
+CelebFaces Attributes Dataset - CelebA, first introduced by Liu et al. (2015), is a large-scale face attributes dataset. It contains 10,177 identities with 202,599 face images. Each image has an annotation of 5 landmark locations and 40 binary attributes. The dataset is publicly available at http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html.
+
+Noted that this dataset is highly unbalanced. Due to the time limitation, we select 3 out of 40 attributes, namely Heavy Makeup, Mouth Slightly Open and Smiling, as suggested by Salem et al. (2020). We then concatenate them into 8 classes to create a multiple label classification task. The input images were all resized into $6 4 \times 6 4$ pixels. Random crop and random rotation were applied as data augmentation at the training stage. No augmentation was applied at the evaluation stage.
+
+# A.1.2 CLASSIFICATION NETWORKS
+
+MNIST
+
+We used a simple, self-defined structure as network classifier for this dataset. Detailed architecture will be mentioned in Table 2.
+
+Table 2: Detailed architecture of MNIST classifier. $^ *$ means the layer is followed by a Dropout layer. $\dagger$ means the layer is followed by a BatchNormalization layer.   
+
+<table><tr><td>Layer</td><td>Filter</td><td>Filter Size</td><td>Stride</td><td>Padding</td><td>Activation</td></tr><tr><td>Conv2dt</td><td>32</td><td>3×3</td><td>2</td><td>1</td><td>ReLU</td></tr><tr><td>Conv2dt</td><td>64</td><td>3×3</td><td>2</td><td>0</td><td>ReLU</td></tr><tr><td>Conv2d</td><td>64</td><td>3×3</td><td>2</td><td>0</td><td>ReLU</td></tr><tr><td>Linear*</td><td>512</td><td>-</td><td></td><td>0</td><td>ReLU</td></tr><tr><td>Linear</td><td>10</td><td>-</td><td>1</td><td>0</td><td>Softmax</td></tr></table>
+
+# CIFAR10 and GTSRB
+
+For the CIFAR-10 and GTSRB datasets, we use PreActRes18 (He et al., 2016) architecture as classification networks.
+
+CelebA
+
+For the CelebA dataset, we use ResNet18 (He et al., 2016) architecture as the classification network.
+
+# A.1.3 RUNNING TIME
+
+We use a system of a GPU RTX 2080Ti and a CPU i7 9700K to conduct our experiment. Detailed inference time of each module will be demonstrated below.
+
+Table 3: Inference time of our modules.   
+
+<table><tr><td>MNIST</td><td>CIFAR10</td><td>GTSRB</td><td>CelebA</td></tr><tr><td>time/sample 4.37 μs</td><td>18.64 μs</td><td>18.65 μs</td><td>87.51 μs</td></tr></table>
+
+# A.2 ALL-TO-ALL ATTACK
+
+Beside the single-target attack scenario, we also verified the effectiveness of WaNet in multi-target scenario, often called all-to-all attack. In this scenario, the input of class $y$ would be targeted into class $c ( y ) = ( y + 1 )$ mod $| C |$ , where $| C |$ is the number of classes.
+
+# A.2.1 EXPERIMENTAL SETUP
+
+We use the same experimental setups as in the single-target scenario, with a small modification. In the attack mode at training, we replace the fixed target label $\hat { c }$ by $( y + 1 )$ mod $| C |$ . In the attack test at evaluation, we also change the expected label similarly.
+
+# A.2.2 ATTACK EXPERIMENT
+
+We conducted attack experiments and reported result in Table 4. While models still achieve stateof-the-art performance on clean data, the attack efficacies slightly decreases. This is due to the fact that the target label now varies from input to input. Though, the lowest attack accuracy is $7 8 . 5 8 \%$ , which is still harmful to real-life deployment.
+
+Similar to all-to-one scenario, we also tested our model with noise mode and recorded the noise accuracy.
+
+# A.2.3 DEFENSE EXPERIMENTS
+
+We repeat the same defense experiments used in the all-to-one scenario. Our backdoor models could also pass all the tests mentioned in Figure 7.
+
+Table 4: All-to-all attack result.   
+
+<table><tr><td>Dataset</td><td>Clean Attack</td><td>Noise</td></tr><tr><td>MNIST</td><td>99.44</td><td>95.90 94.34</td></tr><tr><td>CIFAR-10</td><td>94.43</td><td>93.36 91.47</td></tr><tr><td>GTSRB</td><td>99.39</td><td>98.31 98.96</td></tr><tr><td>CelebA</td><td>78.73</td><td>78.58 76.12</td></tr></table>
+
+![](images/f367396f6d2069d7ae6303e002dc2f7bba043fbf49a75bf4494886421ccd4c5d.jpg)  
+Figure 10: Neural Cleanse against all-to-all scenario.
+
+![](images/240110dedb949e789ebf26b2bac7cc82d7809b12aa3f28b0957d007ebe1904ab.jpg)  
+Figure 11: Fine-pruning against all-to-all scenario.
+
+![](images/f155d1174d16171cb056992f82c5297b7a6cf6d562778244cd94f421ada9778c.jpg)  
+Figure 12: STRIP against all-to-all scenario.
+
+# A.3 ADDITIONAL RESULTS
+
+# A.3.1 ADDIONAL IMAGES FOR METIONED BACKDOOR ATTACK METHODS
+
+We provide additional examples comparing backdoor images from WaNet and from other attack methods in Fig. 13.
+
+# A.3.2 EXPERIMENT ON SPECTRAL SIGNATURE DEFENSE
+
+Tran et al. (2018) proposed a data defense method based on the spectral signature of backdoor training data. Although this data-defense configuration does not match our threat model, we find it useful to verify if our backdoor data have the spectral signature discussed in that paper. We repeated the experiment in the last plot of its Fig. 1, using 5000 clean samples and 1172 backdoor samples generated by WaNet on the CIFAR-10 dataset, which is the same dataset used in the original paper. Fig. 14 plots histograms of the correlations between these samples’ learned representations and their covariance matrix’s top right singular vector. As can be seen, the histograms of the two populations are completely inseparable. Thereby, the backdoor training samples could not be removed from the training dataset using their proposed method. One possible explanation is that the distributional difference between the clean and backdoor correlations in the traditional backdoor methods was the result of the domination of a few backdoor neurons. We do not have such a phenomenon in WaNet, as proved in Fine-Prunning experiments, eliminating the appearance of spectral signature.
+
+![](images/25ebb670000e56552dca7c83822c1e95a8e3ae6ed170efc2d36e723a3c5c3378.jpg)  
+Figure 13: Additional images for mentioned backdoor attack methods.
+
+# A.3.3 THE STABILITY OF WANET
+
+In this section, we verify if WaNet is stable to the variations of the warping field $M$ . We trained 8 WaNet backdoor models, using 8 randomly generated warping fields, in the CIFAR10 dataset. The clean, backdoor, and noise accuracies of the trained models are all stable, as shown in Table 5.
+
+Table 5: The stability of WaNet on the CIFAR-10 dataset.   
+
+<table><tr><td></td><td>Clean</td><td>Backdoor</td><td>Noise</td></tr><tr><td>Accuracy (%)</td><td>94.42 ± 0.08</td><td>99.40 ± 0.21</td><td>93.16 ± 0.43</td></tr></table>
+
+![](images/64b1c0ebfdc1868d7e11bcfaa630829bad191638ceff23bbb1669dfc01d36092.jpg)  
+Figure 14: Spectral Signature
+
+# A.3.4 ADDITIONAL TRIGGER PATTERNS VISUALIZING THE ROLE OF THE NOISE MODE
+
+This section further demonstrates the importance of noise mode by providing trigger patterns optimized by Neural Cleanse on more datasets and with more target classes. Fig. 15a and 15b visualize the patterns on MNIST and GTSRB dataset using backdoor models trained for target label 0, similar to Fig. 8a. Fig. 15c, 15d, and 15e provide results on all three datasets but with backdoor models for label 3. As can be seen, the WaNet models without noise mode training return sparse and small patterns, thus easy to be detected by Neural Cleanse. By including that training mode, the optimized patterns are more crowded and approach clean models’ ones. Note that we skip visualizing the results on the CelebA dataset; its patterns optimized on either clean or backdoor models are all too sparse and small for humans to analyze due to subtle differences between human faces.
+
+![](images/302d62acda83b4f16685d0d77492758ba6c737fa376cd6e835ed81fe8dfa954f.jpg)  
+Figure 15: Additional trigger patterns optimized by Neural Cleanse for the target label (small is bad).

parse/train/eEn8KTtJOx/eEn8KTtJOx_content_list.json

@@ -0,0 +1,2163 @@
+[
+    {
+        "type": "text",
+        "text": "WANET – IMPERCEPTIBLE WARPING-BASED BACKDOOR ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anh Tuan Nguyen1,2, Anh Tuan Tran1,3   \n1VinAI Research, 2Hanoi University of Science and Technology, 3VinUniversity   \n{v.anhnt479,v.anhtt152}@vinai.io ",
+        "bbox": [
+            184,
+            169,
+            712,
+            213
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            265
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "With the thriving of deep learning and the widespread practice of using pretrained networks, backdoor attacks have become an increasing security threat drawing many research interests in recent years. A third-party model can be poisoned in training to work well in normal conditions but behave maliciously when a trigger pattern appears. However, the existing backdoor attacks are all built on noise perturbation triggers, making them noticeable to humans. In this paper, we instead propose using warping-based triggers. The proposed backdoor outperforms the previous methods in a human inspection test by a wide margin, proving its stealthiness. To make such models undetectable by machine defenders, we propose a novel training mode, called the “noise” mode. The trained networks successfully attack and bypass the state of the art defense methods on standard classification datasets, including MNIST, CIFAR-10, GTSRB, and CelebA. Behavior analyses show that our backdoors are transparent to network inspection, further proving this novel attack mechanism’s efficiency. Our code is publicly available at https://github.com/VinAIResearch/ Warping-based_Backdoor_Attack-release. ",
+        "bbox": [
+            233,
+            282,
+            764,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            535,
+            336,
+            551
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning models are essential in many modern systems due to their superior performance compared to classical methods. Most state-of-the-art models, however, require expensive hardware, huge training data, and long training time. Hence, instead of training the models from scratch, it is a common practice to use pre-trained networks provided by third-parties these days. This poses a serious security threat of backdoor attack (Gu et al., 2017). A backdoor model is a network poisoned either at training or finetuning. It can work as a genuine model in the normal condition. However, when a specific trigger appears in the input, the model will act maliciously, as designed by the attacker. Backdoor attack can occur in various tasks, including image recognition (Chen et al., 2017), speech recognition (Liu et al., 2018b), natural language processing (Dai et al., 2019), and reinforcement learning (Hamon et al., 2020). In this paper, we will focus on image classification, the most popular attacking target with possible fatal consequences (e.g., for self-driving car). ",
+        "bbox": [
+            173,
+            568,
+            825,
+            722
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since introduced, backdoor attack has drawn a lot of research interests (Chen et al., 2017; Liu et al., 2018b; Salem et al., 2020; Nguyen & Tran, 2020). In most of these works, trigger patterns are based on patch perturbation or image blending. Recent papers have proposed novel patterns such as sinusoidal strips (Barni et al., 2019), and reflectance (Liu et al., 2020). These backdoor triggers, however, are unnatural and can be easily spotted by humans. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            797
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We believe that the added content, such as noise, strips, or reflectance, causes the backdoor samples generated by the previous methods strikingly detectable. Instead, we propose to use image warping that can deform but preserve image content. We also found that humans are not good at recognizing subtle image warping, while machines are excellent in this task. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            861
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Hence, in this paper, we design a novel, simple, but effective backdoor attack based on image warping called WaNet. We use a small and smooth warping field in generating backdoor images, making the modification unnoticeable, as illustrated in Fig. 1. Our backdoor images are natural and hard to be distinguished from the genuine examples, confirmed by our user study described in Sec. 4.3. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff3c3082a77419286dd5c7d0a7f2e6003a465d0672b89d00b49eab1053d420b0.jpg",
+        "image_caption": [
+            "Figure 1: Comparison between backdoor examples generated by our method and by the previous backdoor attacks. Given the original image (leftmost), we generate the corresponding backdoor images using patch-based attacks (Gu et al., 2017; Liu et al., 2018b), blending-based attack (Chen et al., 2017), SIG (Barni et al., 2019), ReFool (Liu et al., 2020), and our method. For each method, we show the image (top), the magnified $( \\times 2 )$ residual map (bottom). The images generated from the previous attacks are unnatural and can be detected by humans. In constrast, ours is almost identical to the original image, and the difference is unnoticeable. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            220,
+            98,
+            777,
+            244
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To obtain a backdoor model, we first follow the common training procedure by poisoning a part of training data with a fixed ratio of $\\rho _ { a } \\in ( 0 , 1 )$ . While the trained networks provide high clean and attack accuracy, we found that they “cheated” by learning pixel-wise artifacts instead of the warping itself. It makes them easy to be caught by a popular backdoor defense Neural Cleanse. Instead, we add another mode in training, called “noise mode”, to enforce the models to learn only the predefined backdoor warp. This novel training scheme produces satisfactory models that are both effective and stealthy. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            468
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our attack method achieves invisibility without sacrificing accuracy. It performs similarly to stateof-the-art backdoor methods in terms of clean and attack accuracy, verified on common benchmarks such as MNIST, CIFAR-10, GTSRB, and CelebA. Our attack is also undetectable by various backdoor defense mechanisms; none of existing algorithms can recognize or mitigate our backdoor. This is because the attack mechanism of our method is drastically different from any existing attack, breaking the assumptions of all defense methods. ",
+        "bbox": [
+            174,
+            474,
+            823,
+            558
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, we demonstrate that our novel backdoor can be a practical threat by deploying it for physical attacks. We tested the backdoor classifier with camera-captured images of physical screens. Despite image quality degradation via extreme capturing conditions, our backdoor is well-preserved, and the attack accuracy stays near $100 \\%$ . ",
+        "bbox": [
+            174,
+            565,
+            825,
+            621
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In short, we introduce a novel backdoor attack via image warping. To train such a model, we extend the standard backdoor training scheme by introducing a “noise” training mode. The attack is effective, and the backdoor is imperceptible by both humans and computational defense mechanisms. It can be deployed for physical attacks, creating a practical threat to deep-learning-based systems 1. ",
+        "bbox": [
+            174,
+            628,
+            825,
+            684
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            326,
+            722
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 THREAT MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            738,
+            325,
+            752
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Backdoor attacks are techniques of poisoning a system to have a hidden destructive functionality. The poisoned system can work genuinely on clean inputs but misbehave when a specific trigger pattern appears. In the attack mode for image classification, backdoor models can return a predefined target label, normally incorrect, regardless of image content. It allows the attacker to gain illegal benefits. For example, a backdoor face authentication system may allow the attacker to access whenever he puts a specific sticker on the face. ",
+        "bbox": [
+            174,
+            765,
+            825,
+            848
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Backdoors can be injected into the deep model at any stage. We consider model poisoning at training since it is the most used threat model. The attacker has total control over the training process and maliciously alters data for his attack purposes. The poisoned model is then delivered to customers to deploy as-is. In our proposed attack, the attacker selects a fixed warping field and uses it to generate all the backdoor images in training and in testing-time attacks. ",
+        "bbox": [
+            178,
+            856,
+            821,
+            897
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 PREVIOUS BACKDOOR ATTACKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            148,
+            436,
+            164
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We focus on backdoor attacks on image classification. The target network is trained for a classification task $f : \\mathbb { X } \\to \\mathbb { C }$ , where $\\mathbb { X }$ is an image domain and $\\mathbb { C } = \\operatorname { \\bar { \\{ } c _ { 1 } , }  c _ { 2 } , . . . , c _ { M } \\}$ is a set of $M$ target classes. When poisoning $f$ , we enforce it to learn an injection function $\\boldsymbol { B }$ , a target label function $c$ , and alter the network behaviour so that: ",
+        "bbox": [
+            174,
+            174,
+            825,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/36b1a8acd4bbd10452b57955850966510d4a18f0051ef98dee4a4595856b2bf5.jpg",
+        "text": "$$\nf ( \\pmb { x } ) = y , \\quad f ( \\pmb { B } ( \\pmb { x } ) ) = c ( y )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            236,
+            598,
+            253
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "for any pair of clean image $\\pmb { x } \\in \\mathbb { X }$ and the corresponding label $y \\in \\mathbb { C }$ ",
+        "bbox": [
+            174,
+            260,
+            630,
+            275
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The earliest backdoor attack was BadNets (Gu et al., 2017). The authors suggested to poison a portion of training data by replacing each clean data pair $( { \\pmb x } , y )$ with the corresponding poisoned pair $( B ( { \\pmb x } ) , c ( { \\pmb y } ) )$ . The injection function $\\boldsymbol { B }$ simply replaces a fixed patch of the input image by a predefined trigger pattern. As for the target label function $c ( y )$ , the authors proposed two tests: (1) all-to-one with a constant target label $c ( y ) = { \\hat { c } }$ and (2) all-to-all with $c ( y ) = y + 1$ . ",
+        "bbox": [
+            174,
+            280,
+            825,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After BadNets, many variants of backdoor attacks have been introduced. These approaches focus on changing either the backdoor injection process or the injection function $\\boldsymbol { B }$ . ",
+        "bbox": [
+            174,
+            358,
+            821,
+            386
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As for the backdoor injection process, Liu et al. (2018b) proposed to inject backdoor into clean models via fine-tuning instead of the training stage. Yao et al. (2019) suggested hiding backdoor inside latent neurons for transfer learning. Many recent studies (Turner et al., 2019; Barni et al., 2019; Liu et al., 2020), injected backdoor only on samples with unchanged labels, i.e., the target $c ( y )$ is the same as the ground-truth label $y$ , to dodge label inspection by humans. ",
+        "bbox": [
+            174,
+            392,
+            825,
+            463
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we focus on the development of a good injection function $\\boldsymbol { B }$ . Most of the popular attack methods rely on fixed patch-based triggers. Chen et al. (2017) used image blending to embed the trigger into the input image, and Nguyen & Tran (2020) extended it to be input-aware. Salem et al. (2020) varied the patch-based trigger locations and patterns to make it “dynamic”. Barni et al. (2019) employed sinusoidal strips as the trigger alongside the clean-label strategy. Lately, Liu et al. (2020) proposed to disguise backdoor triggers as reflectance to make the poisoned images look natural. The backdoor images generated by these attacks, however, are easy to be spotted by humans. We instead propose an “invisible” backdoor that is imperceptible by even sharp-eyed people. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 BACKDOOR DEFENSE METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            598,
+            434,
+            612
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As the threat of backdoor attacks becomes more apparent, backdoor defense research is emerging. Based on usage scenarios, we can classify them into three groups: training defense, model defense, and testing-time defense. ",
+        "bbox": [
+            176,
+            623,
+            825,
+            665
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Training defense assumes the defender has control over the training process, and the adversary attacks by providing infected training data (Tran et al., 2018). This assumption, however, does not match our threat model, where the already-trained backdoor model is provided by a third party. This mechanism is not applicable to our situation and will not be considered further in this paper. ",
+        "bbox": [
+            174,
+            672,
+            823,
+            728
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Model defenses aim to verify or mitigate the provided model before deployment. Fine-Pruning (Liu et al., 2018a) suggested to prune the dormant neurons, defined by analyses on a clean image set, to mitigate the backdoor if present. Neural Cleanse (Wang et al., 2019) was the first work that could detect backdoor models. It optimized a patch-based trigger candidate for each target label, then detected if any candidate was abnormally smaller than the others as a backdoor indicator. ABS (Liu et al., 2019) scanned the neurons and generated trigger candidates by reverse engineering. Cheng et al. (2019) used GradCam (Selvaraju et al., 2017) to analyze the network behavior on a clean input image with and without the synthesized trigger to detect anomalies. Zhao et al. (2019) applied mode connectivity to effectively mitigate backdoor while keeping acceptable performance. Lately, Kolouri et al. (2020) introduced universal litmus patterns that can be fed to the network to detect backdoor. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            875
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlike model defense, testing-time defenses inspect models after deployment with the presence of input images. It focuses on verifying if the provided image is poisoned and how to mitigate it. STRIP (Gao et al., 2019) exploited the persistent outcome of the backdoor image under perturbations for detection. In contrast, Neo (Udeshi et al., 2019) searched for the candidate trigger patches where region blocking changed the predicted outputs. Recently, Doan et al. (2019) used GradCam inspection to detect potential backdoor locations. In all these methods, the trigger candidates were then verified by being injected into a set of clean images. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A common assumption in all previous defense methods is that the backdoor triggers are image patches. We instead propose a novel attack mechanism based on image warping, undermining the foundation of these methods. ",
+        "bbox": [
+            174,
+            166,
+            823,
+            208
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.4 ELASTIC IMAGE WARPING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            226,
+            397,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Image warping is a basic image processing technique that deforms an image by applying the geometric transformation. The transformation can be affine, projective, elastic, or non-elastic. In this work, we propose to use elastic image warping given its advantages over the others: (1) Affine and projective transformations are naturally introduced to clean images via the image capturing process. If we apply these transformations to these images, the transformed images can be identical to other clean images that are of the same scenes but captured at different viewpoints. Hence, these transformations are not suitable to generate backdoor examples, particularly in physical attacks. (2) Elastic transformation still generates natural outputs while non-elastic one does not. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The most popular elastic warping technique is Thin-Plate Splines (TPS) (Duchon, 1977). TPS can interpolate a smooth warping field to transform the entire image given a set of control points with known original and target 2D coordinates. TPS was adopted in Spatial Transformer Networks (Jaderberg et al., 2015), the first deep learning study incorporating differential image warping. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We believe that elastic image warping can be utilized to generate invisible backdoor triggers. Unlike previous attack methods that introduce extra and independent information to an input image, elastic image warping only manipulates existing pixels of the image. Humans, while being excellent in spotting incongruent part of an image, are bad at recognizing small geometric transformations. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            488
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 WARPING-BASED BACKDOOR ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            508,
+            526,
+            525
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We now describe our novel backdoor attack method WaNet, which stand for Warping-based poisoned Networks. WaNet are designed to be stealthy to both machine and human inspections. ",
+        "bbox": [
+            173,
+            540,
+            823,
+            568
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 OVERVIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            584,
+            290,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Recall that a classification network is a function $f : \\mathbb { X } \\to \\mathbb { C }$ , in which $\\mathbb { X }$ is an input image domain and $\\mathbb { C }$ is a set of target classes. To train $f$ , a training dataset $\\mathbb { S } = \\{ ( \\mathbf { x } _ { i } , y _ { i } ) | \\mathbf { x } _ { i } \\in \\mathbb { X } , \\mathbf { \\bar { y } } _ { i } \\in \\mathbb { C } , \\bar { i } = \\overline { { 1 , N } } \\}$ is provided. We follow the training scheme of BadNets to poison a subset of $\\mathbb { S }$ with ratio $\\rho _ { a }$ for backdoor training. Each clean pair $( { \\pmb x } , y )$ will be replaced by a backdoor pair $( B ( { \\pmb x } ) , c ( { \\pmb y } ) )$ , in which $\\boldsymbol { B }$ is the backdoor injection function and $c ( y )$ is the target label function. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our main focus is to redesign the injection function $\\boldsymbol { B }$ based on image warping. We construct $\\boldsymbol { B }$ using a warping function $\\mathcal { W }$ and a predefined warping field $M$ : ",
+        "bbox": [
+            174,
+            688,
+            823,
+            715
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2eabeda75b20dfe34457da00858f211ed2c110acf3e6e90ba87948753a5a754.jpg",
+        "text": "$$\n\\ B ( \\pmb { x } ) = \\mathscr { W } ( \\pmb { x } , \\pmb { M } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            720,
+            565,
+            738
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$M$ acts like a motion field; it defines the relative sampling location of backward warping for each point in the target image. $\\mathcal { W }$ allows a floating-point warping field as input. When a sampling pixel falls on non-integer 2D coordinates, it will be bi-linear interpolated. To implement $\\mathcal { W }$ , we rely on the public API grid sample provided by PyTorch. However, this API inputs a grid of normalized absolute 2D coordinates of the sampling points. To use that API, we first sum $M$ with an identity sampling grid, then normalize to $[ - 1 , 1 ]$ to get the required grid input. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            828
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 WARPING FIELD GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            843,
+            421,
+            858
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The warping field $M$ is a crucial component; it must guarantee that the warped images are both natural and effective for attacking purposes. Hence, $M$ are desired to satisfy the following properties: ",
+        "bbox": [
+            173,
+            869,
+            823,
+            898
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Small: $M$ should be small, to be unnoticeable to humans, ",
+        "bbox": [
+            217,
+            909,
+            614,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/81132bcaa7c20024d7ad25d9b48489f426beb6a86cbc53a6818d3cb183f3fe7e.jpg",
+        "image_caption": [
+            "Figure 2: Process of creating the warping field $M$ and using it to generate poisoned images. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            101,
+            789,
+            204
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7e29ff05e3b5688eba7a923ac82091bbc493f7a1cfef1eae1733fbd455b6f02a.jpg",
+        "image_caption": [
+            "Figure 3: Effect of different hyper-parameters on the warping result. For each warped image, we show the image (top), the magnified $( \\times 2 )$ residual map (bottom). The PSNR and LPIPS (Zhang et al., 2018) scores are computed at resolution $2 2 4 \\times 2 2 4$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            227,
+            759,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "• Elastic: $M$ should be elastic, i.e., smooth and non-flat, to generate natural looking images, • Within image boundary: $M$ should not exceed the image boundary, to avoid creating suspicious black/plain outer area. ",
+        "bbox": [
+            217,
+            419,
+            825,
+            465
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To get such a warping field, we borrow the idea of using control points from TPS but simplify the interpolation method. The process of generating the desired warp is illustrated by Fig. 2 and is described in the following subsections. ",
+        "bbox": [
+            179,
+            476,
+            825,
+            518
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Selecting the control grid We first select the control points. For simplicity, we pick the target points on a uniform grid of size $k \\times k$ over the entire image. Their backward warping field is denoted as $\\boldsymbol { P } \\in \\mathbb { R } ^ { k \\times k \\times 2 }$ . We use a parameter $s$ to define the strength of $_ { r }$ and generate $_ { r }$ as following: ",
+        "bbox": [
+            173,
+            530,
+            825,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cec87e5d37d05f80baf7fb6919de244aaab491692fe58bddf3986e3112b963cc.jpg",
+        "text": "$$\nP = \\psi ( r a n d _ { [ - 1 , 1 ] } ( k , k , 2 ) ) \\times s\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            582,
+            606,
+            601
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "in which $r a n d _ { [ - 1 , 1 ] } ( . . . )$ is a function returning random tensor with the input shape and element value in the range $[ - 1 , 1 ]$ and $\\psi$ is a normalization function. In this paper, we normalize the tensor elements by their mean absolute value: ",
+        "bbox": [
+            173,
+            608,
+            825,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6c84a593d5322e47a50ce514c34cfd3797f3234ebd1723d237af2b29ccdffb73.jpg",
+        "text": "$$\n\\psi ( A ) = { \\frac { A } { { \\frac { 1 } { s i z e ( A ) } } \\sum _ { a _ { i } \\in A } \\left| a _ { i } \\right| } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            655,
+            596,
+            694
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Upsampling From the control points, we interpolate the warping field of the entire image. Since these points are in a uniform grid covering the entire image, instead of using a complex spline-based interpolation like in TPS, we can simply apply bicubic interpolation. We denote the output of this step as $M _ { 0 } = \\uparrow P \\in \\mathbb { R } ^ { h \\times w \\times 2 }$ , with $h$ and $w$ being the image height and width respectively. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            756
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Clipping Finally, we apply a clipping function $\\phi$ so that the sampling points do not fall outside of the image border. The process of generating $M$ can be summarized by the equation: ",
+        "bbox": [
+            171,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a3eb65439531dd325f0ffe738aae13134ff115beeeb75d05d0cb00978b26c8c.jpg",
+        "text": "$$\n{ \\cal M } = \\phi ( \\uparrow ( \\psi ( r a n d _ { [ - 1 , 1 ] } ( k , k , 2 ) ) \\times s ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            799,
+            635,
+            818
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We investigate the effect of the hyper-parameters $k$ and $s$ qualitatively in Fig. 3. The warping effect is almost invisible when $k < 6$ and $s < 0 . 7 5$ . ",
+        "bbox": [
+            174,
+            824,
+            826,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 RUNNING MODES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            336,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After computing the warping field $M$ , we can train WaNet with with two modes, clean and attack, as the standard protocol. However, the models trained by that algorithm, while still achieving high ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3ed2c75ea36444996fc393d65dbbcf12766b4c659f7673cc736ef40f18809b7.jpg",
+        "image_caption": [
+            "Figure 4: Training pipeline with three running modes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            333,
+            99,
+            663,
+            224
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/ca04708b4a2d8b46d98f2e9c0480cb1c70f223fc550803c2276acec1d6ac343b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            262,
+            826,
+            381
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "accuracy in both clean and attack tests, tend to learn pixel-level artifacts instead of the warping. They are, therefore, easily exposed by a backdoor defense method such as Neural Cleanse. We will discuss more details in the ablation studies in Section 4.6. ",
+        "bbox": [
+            176,
+            405,
+            823,
+            446
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To resolve this problem, we propose a novel training mode alongside the clean and attack mode, called noise mode. The idea is simple: when applying a random warping field $M ^ { \\prime } \\ne M$ , the network should not trigger the backdoor but return the correct class prediction. ",
+        "bbox": [
+            176,
+            454,
+            823,
+            496
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4 illustrates three running modes in our training pipelines. We first select the backdoor probability $\\rho _ { a } \\in ( 0 , 1 )$ and the noise probability $\\rho _ { n } \\in ( 0 , 1 )$ such that $\\rho _ { a } + \\rho _ { n } < 1$ . Then, for each clean input $( { \\pmb x } , y )$ , we randomly select one of three modes and alter that pair accordingly: ",
+        "bbox": [
+            173,
+            502,
+            823,
+            546
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/00ea6e30f19f12228140b86d18c16a8a341ea310a4649bd95731d4473013663e.jpg",
+        "text": "$$\n( \\pmb { x } , y ) \\mapsto \\left\\{ \\begin{array} { l l } { ( \\pmb { x } , y ) } & { \\mathrm { w i t h ~ p r o b a b i l i t y ~ } 1 - \\rho _ { a } - \\rho _ { n } } \\\\ { ( \\mathcal { W } ( \\pmb { x } , \\pmb { M } ) , c ( y ) ) } & { \\mathrm { w i t h ~ p r o b a b i l i t y ~ } \\rho _ { a } } \\\\ { ( \\mathcal { W } ( \\pmb { x } , \\pmb { M } + r a n d _ { [ - 1 , 1 ] } ( h , w , 2 ) ) , y ) } & { \\mathrm { w i t h ~ p r o b a b i l i t y ~ } \\rho _ { n } } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            556,
+            766,
+            611
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Note that with the noise mode, instead of using a totally random warping field, we form it by adding Gaussian noise to $M$ for a more effective training. The modified training set is then used to train $f$ . ",
+        "bbox": [
+            173,
+            619,
+            825,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            326,
+            689
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            707,
+            375,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Following the previous backdoor attack papers, we performed experiments on four datasets: MNIST (LeCun et al., 1998), CIFAR-10 (Krizhevsky et al., 2009), GTSRB (Stallkamp et al., 2012) and CelebA (Liu et al., 2015). Note that CelebA dataset has annotations for 40 independent binary attributes, which is not suitable for multi-class classification. Therefore, we follow the configuration suggested by Salem et al. (2020) to select the top three most balanced attributes, including Heavy Makeup, Mouth Slightly Open, and Smiling, then concatenate them to create eight classification classes. Their detail information are shown in Table 1. To build the classifier $f$ for the color image datasets, we used Pre-activation Resnet-18 (He et al., 2016) for the CIFAR-10 and GTSRB datasets as suggested by Kang (2020), and Resnet-18 for the CelebA dataset. As for the grayscale dataset MNIST, we defined a simple network structure as reported in Table 1. ",
+        "bbox": [
+            173,
+            734,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We trained the networks using the SGD optimizer. The initial learning rate was 0.01, which was reduced by a factor of 10 after each 100 training epochs. The networks were trained until convergence. We used $k = 4$ , $s = 0 . 5$ , $\\rho _ { a } = 0 . 1$ , and $\\rho _ { n } = 0 . 2$ . ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "",
+        "table_caption": [
+            "Table 1: Datasets and the classifiers used in our experiments. Each ConvBlock consists of a $3 \\times 3$ convolution (stride $^ { \\cdot = 2 }$ ), a BatchNorm, and a ReLU layer. "
+        ],
+        "table_footnote": [],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9dd4edb918d24b7d2e5819528c233a4e8a5f2da0fa8f130159fec55c5486ad46.jpg",
+        "image_caption": [
+            "Figure 6: Human inspection tests: (a) Success fooling rates of each backdoor method, (b) The most distinguishable cases from WaNet. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            131,
+            808,
+            339
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 ATTACK EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            392,
+            375,
+            405
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We trained and tested the backdoor models in all-to-one configuration, i.e., $c ( y ) = \\hat { c } \\forall y$ . The accuracy values in clean mode, attack mode, and the noise mode are reported in Fig. 5a. As can be seen, with clean images, the networks could correctly classify them like any benign models, with accuracy near $100 \\%$ on MNIST/GTSRB, $9 4 . 1 5 \\%$ on CIFAR-10, and $7 9 . 7 7 \\%$ on CelebA. When applying the pre-defined image warping, the attack success rate was near $100 \\%$ on all datasets. However, when using a random warping, the classifiers still recognized the true image class with a similar accuracy as in the clean mode. This result is impressive given the fact that the poisoned images look almost identical to the original, as can be seen in Fig. 5b. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            523
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our method’s robustness in real-life scenarios, we also tested if backdoor images would still be misclassified even when being distorted by the capturing process. We showed 50 clean and 50 backdoor images on a screen and recaptured them using a phone camera. Our model still worked well on recaptured images, obtaining $98 \\%$ clean accuracy and $96 \\%$ attack success rate. Fig. 5c displays an example of our test. The clean image was recognized correctly as “automobile”, while the look-a-like backdoor image was recognized as the “airplane” attack class. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            613
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 HUMAN INSPECTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            359,
+            640
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To examine the realisticity of our backdoor and the previous methods, we created user studies with human inspection. First, we randomly selected 25 images from the GTSRB dataset. Second, for each backdoor injection function, we created the corresponding 25 backdoor images and mixed them with the original to obtain a set of 50 images. Finally, we asked 40 people to classify whether each image was genuine, collecting 2000 answers per method. The participants were trained about the mechanism and characteristics of the attack before answering the questions. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            728
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We collected the answers and reported the percentage of incorrect answers as the success fooling rates in Fig. 6a. Note that when the backdoor examples are more indistinguishable from the clean ones, the testers will find it harder to decide an image is clean or poisoned. Hence, better backdoor methods led to higher fooling rates on not only backdoor inputs but also on clean ones. The rates from previous methods are low, with maximum $7 . 7 \\%$ on all inputs, implying that they are obvious to humans to detect. In contrast, our rate is $28 \\%$ , four times their best number. It confirms that WaNet is stealthy and hard to detect, even with trained people. ",
+        "bbox": [
+            174,
+            736,
+            825,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Although our backdoor images are natural-looking, some of them have subtle properties that can be detected by trained testers. We provide two of the most detected backdoor examples from WaNet in Fig. 6b. In the first case, the circle sign is not entirely round. In the second case, the right edge of the traffic sign is slightly curved. Although these conditions can be found on real-life traffic signs, they are not common in the testing dataset GTSRB. These images are of the minority, and our fooling rate on backdoor images is $3 8 . 6 \\%$ , not far away from the rate of $50 \\%$ in random selection. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f7f9082c0ff5c9c114493eea47e6bfd11a3b49ea7cbbcaab4d630a51fb8631cd.jpg",
+        "image_caption": [
+            "Figure 7: Experiments on verifying WaNet by the state-of-the-art defense and visualization methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            98,
+            826,
+            446
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 DEFENSE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            482,
+            383,
+            496
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We will now test the trained models against the popular backdoor defense mechanisms, including Neural Cleanse, Fine-Prunning (Model defenses), and STRIPS (Testing-time defense). ",
+        "bbox": [
+            174,
+            507,
+            821,
+            536
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neural Cleanse (Wang et al., 2019) is a model-defense method based on the pattern optimization approach. It assumes that the backdoor is patch-based. For each class label, Neural Cleanse computes the optimal patch pattern to convert any clean input to that target label. It then checks if any label has a significantly smaller pattern as a sign of backdoor. Neural Cleanse quantifies it by the Anomaly Index metric with the clean/backdoor threshold $\\tau = 2$ . We ran Neural Cleanse over our WaNet models and report the numbers in Fig. 7c. WaNet passed the test on all datasets; its scores are even smaller than the clean model ones on MNIST and CIFAR-10. We can explain it by the fact that our backdoor relies on warping, a different mechanism compared with patch-based blending. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            660
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Fine-Pruning (Liu et al., 2018a), instead, focuses on neuron analyses. Given a specific layer, it analyzes the neuron responses on a set of clean images and detects the dormant neurons, assuming they are more likely to tie to the backdoor. These neurons are then gradually pruned to mitigate the backdoor. We tested Fine-Pruning on our models and plotting the network accuracy, either clean or attack, with respect to the number of neurons pruned in Fig. 7a. On all datasets, at no point is the clean accuracy considerably higher than the attack one, making backdoor mitigation impossible. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            756
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "STRIP (Gao et al., 2019) is a representative of the testing-time defense approach. It examines the model with the presence of the input image. STRIP works by perturbing the input image through a set of clean images from different classes and raising the alarm if the prediction is persistent, indicating by low entropy. With WaNet, the perturbation operation of STRIP will modify the image content and break the backdoor warping if present. Hence, WaNet behaves like genuine models, with similar entropy ranges, as shown in Fig. 7b. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            852
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.5 NETWORK INSPECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            375,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Visualization tools, such as GradCam (Selvaraju et al., 2017), are helpful in inspecting network behaviors. Patch-based backdoor methods can be exposed easily due to the use of small trigger regions, as pointed out by Cheng et al. (2019); Doan et al. (2019). Our attack method is based on the warping on the entire image, so it is undetectable by this algorithm. We visualize activation based on the label that has the highest prediction score in Fig. 7d. With clean models, that label is for the correct class label. With WaNet and backdoor inputs, it is the backdoor label $\\hat { c }$ . As can be seen, the visualization heatmaps of WaNet look like the ones from any clean model. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/902edff74c83bc38bd176b15e3f183a6000bf9a3c5c93a60ca8a5a9523d32ea0.jpg",
+        "image_caption": [
+            "Figure 8: Ablation studies on CIFAR-10 dataset: (a) Role of the noise mode training, (b,c) Network performance when changing warping hyper-parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            112,
+            797,
+            229
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            286,
+            825,
+            356
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.6 ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            351,
+            387
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Role of the noise mode Without the noise mode, we could still train a backdoor model with similar clean and attack accuracy. However, these models failed the defense test with Neural Cleanse as shown in Fig. 9, and the optimized trigger patterns revealed their true behavior. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            446
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/cd132370d6ae5f49b8a4e76bbc6c4973500ffc7177fc53c933bb82191fa21597.jpg",
+        "image_caption": [
+            "Figure 9: Networks’ performance against Neural Cleanse with and without noise mode. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            316,
+            458,
+            676,
+            589
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Fig. 8a displays the trigger patterns optimized by Neural Cleanse for the attacking class “airplane” on CIFAR-10. With the clean model, this pattern has an airplane-like shape, and it is big enough to rewrite image content given any input. With our model trained without noise mode, the optimized pattern just consists of scattered points. This pattern is remarkably smaller, making the model caught by Neural Cleanse. It reveals that the model did not learn the specific backdoor warping; instead, it remembered the pixel-wise artifacts. By adding the noise training mode, our model no longer relies on those artifacts, and the optimized pattern looks similar to the clean model’s one. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            714
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Other hyper-parameters We investigated the effect of the warping hyper-parameters, including the strength $s$ and the grid size $k$ . Fig. 8b and 8c show the clean, attack, and noise mode accuracy of our network on the CIFAR-10 dataset when changing each of these parameters. When $k$ or $s$ is small, the backdoor images are similar to the clean ones. However, since they are a minority $( \\rho _ { a } = 0 . 1 )$ , the network would treat them like data with noisy labels in those scenarios. Hence, clean and noise accuracies are stable across configurations. In contrast, backdoor accuracy suffers on the left side of the plots. It gradually increases when $s$ or $k$ is small, then saturates and stays near $100 \\%$ . ",
+        "bbox": [
+            173,
+            726,
+            825,
+            824
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION AND FUTURE WORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            837,
+            500,
+            852
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "This paper introduces a novel backdoor attack method that generates backdoor images via subtle image warping. The backdoor images are proved to be natural and undetectable by humans. We incorporate in training a novel “noise” mode, making it stealthy and pass all the known defense methods. It opens a new domain of attack mechanism and encourages future defense research. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mauro Barni, Kassem Kallas, and Benedetta Tondi. A new backdoor attack in cnns by training set corruption without label poisoning. In 2019 IEEE International Conference on Image Processing (ICIP), pp. 101–105. IEEE, 2019. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xinyun Chen, Chang Liu, Bo Li, Kimberly Lu, and Dawn Song. Targeted backdoor attacks on deep learning systems using data poisoning. arXiv preprint arXiv:1712.05526, 2017. ",
+        "bbox": [
+            169,
+            176,
+            823,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Hao Cheng, Kaidi Xu, Sijia Liu, Pin-Yu Chen, Pu Zhao, and Xue Lin. Defending against Backdoor Attack on Deep Neural Networks. In Proceedings of the 25th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining Workshop, 2019. ",
+        "bbox": [
+            174,
+            214,
+            821,
+            258
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jiazhu Dai, Chuanshuai Chen, and Yufeng Li. A backdoor attack against lstm-based text classification systems. IEEE Access, 7:138872–138878, 2019. ",
+        "bbox": [
+            169,
+            267,
+            823,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bao Gia Doan, Ehsan Abbasnejad, and Damith C. Ranasinghe. Februus: Input Purification Defense Against Trojan Attacks on Deep Neural Network Systems. arXiv, Aug 2019. URL https: //arxiv.org/abs/1908.03369. ",
+        "bbox": [
+            174,
+            304,
+            821,
+            348
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean Duchon. Splines minimizing rotation-invariant semi-norms in sobolev spaces. In Constructive theory of functions of several variables, pp. 85–100. Springer, 1977. ",
+        "bbox": [
+            171,
+            357,
+            823,
+            386
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yansong Gao, Change Xu, Derui Wang, Shiping Chen, Damith C Ranasinghe, and Surya Nepal. Strip: A defence against trojan attacks on deep neural networks. In Proceedings of the 35th Annual Computer Security Applications Conference, pp. 113–125, 2019. ",
+        "bbox": [
+            173,
+            393,
+            823,
+            438
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tianyu Gu, Brendan Dolan-Gavitt, and Siddharth Garg. Badnets: Identifying vulnerabilities in the machine learning model supply chain. In Proceedings of Machine Learning and Computer Security Workshop, 2017. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            489
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ronan Hamon, Henrik Junklewitz, and Ignacio Sanchez. Robustness and explainability of artificial intelligence. Publications Office of the European Union, 2020. ",
+        "bbox": [
+            173,
+            498,
+            823,
+            527
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European conference on computer vision, pp. 630–645. Springer, 2016. ",
+        "bbox": [
+            174,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Karen Simonyan, Andrew Zisserman, et al. Spatial transformer networks. In Advances in neural information processing systems, pp. 2017–2025, 2015. ",
+        "bbox": [
+            173,
+            574,
+            823,
+            603
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Liu Kang. pytorch-cifar, May 2020. URL https://github.com/kuangliu/ pytorch-cifar. [Online; accessed 4. Jun. 2020]. ",
+        "bbox": [
+            173,
+            611,
+            823,
+            642
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Soheil Kolouri, Aniruddha Saha, Hamed Pirsiavash, and Heiko Hoffmann. Universal litmus patterns: Revealing backdoor attacks in cnns. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 301–310, 2020. ",
+        "bbox": [
+            176,
+            650,
+            823,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky et al. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            173,
+            702,
+            723,
+            718
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            169,
+            726,
+            823,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kang Liu, Brendan Dolan-Gavitt, and Siddharth Garg. Fine-pruning: Defending against backdooring attacks on deep neural networks. In Proceedings of International Symposium on Research in Attacks, Intrusions, and Defenses, 2018a. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yingqi Liu, Shiqing Ma, Yousra Aafer, Wen-Chuan Lee, Juan Zhai, Weihang Wang, and Xiangyu Zhang. Trojaning attack on neural networks. In Proceedings of Network and Distributed System Security Symposium, 2018b. ",
+        "bbox": [
+            173,
+            815,
+            825,
+            858
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yingqi Liu, Wen-Chuan Lee, Guanhong Tao, Shiqing Ma, Yousra Aafer, and Xiangyu Zhang. Abs: Scanning neural networks for back-doors by artificial brain stimulation. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, pp. 1265–1282, 2019. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yunfei Liu, Xingjun Ma, James Bailey, and Feng Lu. Reflection backdoor: A natural backdoor attack on deep neural networks. 2020. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, and Xiaoou Tang. Deep learning face attributes in the wild. In Proceedings of International Conference on Computer Vision (ICCV), December 2015. ",
+        "bbox": [
+            173,
+            141,
+            821,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tuan Anh Nguyen and Anh Tran. Input-aware dynamic backdoor attack. In H. Larochelle, M. Ranzato, R. Hadsell, M. F. Balcan, and H. Lin (eds.), Advances in Neural Information Processing Systems, volume 33, pp. 3454–3464. Curran Associates, Inc., 2020. URL https://proceedings.neurips.cc/paper/2020/file/ 234e691320c0ad5b45ee3c96d0d7b8f8-Paper.pdf. ",
+        "bbox": [
+            174,
+            179,
+            825,
+            250
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ahmed Salem, Rui Wen, Michael Backes, Shiqing Ma, and Yang Zhang. Dynamic backdoor attacks against machine learning models. arXiv preprint arXiv:2003.03675, 2020. ",
+        "bbox": [
+            176,
+            257,
+            820,
+            287
+        ],
+        "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,
+            295,
+            825,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Johannes Stallkamp, Marc Schlipsing, Jan Salmen, and Christian Igel. Man vs. computer: Benchmarking machine learning algorithms for traffic sign recognition. Neural networks, 32:323–332, 2012. ",
+        "bbox": [
+            173,
+            361,
+            825,
+            404
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Brandon Tran, Jerry Li, and Aleksander Madry. Spectral signatures in backdoor attacks. In Proceedings of Advances in Neural Information Processing Systems, 2018. ",
+        "bbox": [
+            171,
+            412,
+            823,
+            441
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alexander Turner, Dimitris Tsipras, and Aleksander Madry. Clean-label backdoor attacks. https://people.csail.mit.edu/madry/lab/, 2019. ",
+        "bbox": [
+            173,
+            450,
+            823,
+            479
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sakshi Udeshi, Shanshan Peng, Gerald Woo, Lionell Loh, Louth Rawshan, and Sudipta Chattopadhyay. Model agnostic defence against backdoor attacks in machine learning. arXiv preprint arXiv:1908.02203, 2019. ",
+        "bbox": [
+            173,
+            488,
+            823,
+            530
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bolun Wang, Yuanshun Yao, Shawn Shan, Huiying Li, Bimal Viswanath, Haitao Zheng, and Ben Y Zhao. Neural cleanse: Identifying and mitigating backdoor attacks in neural networks. In Proceedings of 40th IEEE Symposium on Security and Privacy, 2019. ",
+        "bbox": [
+            174,
+            539,
+            823,
+            583
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuanshun Yao, Huiying Li, Haitao Zheng, and Ben Y Zhao. Latent backdoor attacks on deep neural networks. In Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, pp. 2041–2055, 2019. ",
+        "bbox": [
+            174,
+            590,
+            823,
+            635
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. In CVPR, 2018. ",
+        "bbox": [
+            169,
+            642,
+            823,
+            672
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pu Zhao, Pin-Yu Chen, Payel Das, Karthikeyan Natesan Ramamurthy, and Xue Lin. Bridging mode connectivity in loss landscapes and adversarial robustness. In International Conference on Learning Representations, 2019. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            723
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 SYSTEM DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            339,
+            151
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.1 DATASETS ",
+        "bbox": [
+            176,
+            165,
+            305,
+            179
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We used 3 standard datasets, from simple to more complex ones, to conduct our experiments. As the datasets are all used in previous related works, our results would be more comparable and reliable. ",
+        "bbox": [
+            176,
+            193,
+            823,
+            219
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "MNIST ",
+        "bbox": [
+            174,
+            233,
+            227,
+            247
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The dataset (LeCun et al., 1998) is a subset of the larger dataset available from the National Institute of Technology (NIST). This dataset consists of 70,000 grayscale, $2 8 \\times 2 8$ images, divided into a training set of 60,000 images and a test set of 10,000 images. Original dataset could be found at http://yann.lecun.com/exdb/mnist/. ",
+        "bbox": [
+            174,
+            255,
+            825,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We applied random cropping and random rotation as data augmentation for the training process.   \nDuring the evaluation stage, no augmentation is applied. ",
+        "bbox": [
+            171,
+            318,
+            821,
+            345
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CIFAR10 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            359,
+            240,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The dataset was introduced the first time by Krizhevsky et al. (2009). It is a labeled subset of the 80-millions-tiny-images dataset, collected by Alex Krizhevsky, Vinod Nair and Geoffrey Hinton, consists of 60,000 color images at the resolution of $3 2 \\times 3 2$ . The dataset contains 10 classes, with 6,000 images per one. It is divided into two subsets: a training set of 50,000 images and a test set of 10,000 images. The data set is public and avalable at https://www.cs.toronto.edu/ ˜kriz/cifar.html. ",
+        "bbox": [
+            174,
+            380,
+            825,
+            463
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "During training stage, random crop, random rotation and random horizontal flip were applied as data augmentation. No augmentation was added at the evaluation stage. ",
+        "bbox": [
+            176,
+            470,
+            821,
+            500
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "GTSRB ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            512,
+            228,
+            526
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The German Traffic Sign Recognition Benchmark - the GTSRB (Stallkamp et al. (2012)) is used as an official dataset for the challenge held at the International Joint Conference on Neural Network (IJCNN) 2011. This dataset consists of 60,000 images with 43 classes and the resolution varying from $3 2 \\times 3 2$ to $2 5 0 \\times 2 5 0$ . It is divided into a training set of 39,209 images and a test set of 12,630. The dataset could be found at http://benchmark.ini.rub.de/?section $=$ gtsrb&subsection $=$ dataset. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Input images were all resized into $3 2 \\times 3 2$ pixels, then applied random crop and random rotation at the training stage. No augmentation was used at the evaluation stage. ",
+        "bbox": [
+            174,
+            625,
+            823,
+            652
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CelebA",
+        "text_level": 1,
+        "bbox": [
+            174,
+            666,
+            225,
+            679
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "CelebFaces Attributes Dataset - CelebA, first introduced by Liu et al. (2015), is a large-scale face attributes dataset. It contains 10,177 identities with 202,599 face images. Each image has an annotation of 5 landmark locations and 40 binary attributes. The dataset is publicly available at http://mmlab.ie.cuhk.edu.hk/projects/CelebA.html. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            743
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Noted that this dataset is highly unbalanced. Due to the time limitation, we select 3 out of 40 attributes, namely Heavy Makeup, Mouth Slightly Open and Smiling, as suggested by Salem et al. (2020). We then concatenate them into 8 classes to create a multiple label classification task. The input images were all resized into $6 4 \\times 6 4$ pixels. Random crop and random rotation were applied as data augmentation at the training stage. No augmentation was applied at the evaluation stage. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            820
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1.2 CLASSIFICATION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            840,
+            431,
+            856
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "MNIST ",
+        "bbox": [
+            174,
+            873,
+            227,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We used a simple, self-defined structure as network classifier for this dataset. Detailed architecture will be mentioned in Table 2. ",
+        "bbox": [
+            176,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/920d77274ec75f095d9af05d4b43071adb80376321f7d71291854521cc474eef.jpg",
+        "table_caption": [
+            "Table 2: Detailed architecture of MNIST classifier. $^ *$ means the layer is followed by a Dropout layer. $\\dagger$ means the layer is followed by a BatchNormalization layer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Layer</td><td>Filter</td><td>Filter Size</td><td>Stride</td><td>Padding</td><td>Activation</td></tr><tr><td>Conv2dt</td><td>32</td><td>3×3</td><td>2</td><td>1</td><td>ReLU</td></tr><tr><td>Conv2dt</td><td>64</td><td>3×3</td><td>2</td><td>0</td><td>ReLU</td></tr><tr><td>Conv2d</td><td>64</td><td>3×3</td><td>2</td><td>0</td><td>ReLU</td></tr><tr><td>Linear*</td><td>512</td><td>-</td><td></td><td>0</td><td>ReLU</td></tr><tr><td>Linear</td><td>10</td><td>-</td><td>1</td><td>0</td><td>Softmax</td></tr></table>",
+        "bbox": [
+            294,
+            141,
+            702,
+            243
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CIFAR10 and GTSRB ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            267,
+            323,
+            282
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the CIFAR-10 and GTSRB datasets, we use PreActRes18 (He et al., 2016) architecture as classification networks. ",
+        "bbox": [
+            173,
+            290,
+            823,
+            316
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "CelebA",
+        "bbox": [
+            174,
+            330,
+            225,
+            344
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "For the CelebA dataset, we use ResNet18 (He et al., 2016) architecture as the classification network. ",
+        "bbox": [
+            173,
+            352,
+            823,
+            367
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1.3 RUNNING TIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            382,
+            339,
+            396
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use a system of a GPU RTX 2080Ti and a CPU i7 9700K to conduct our experiment. Detailed inference time of each module will be demonstrated below. ",
+        "bbox": [
+            171,
+            406,
+            823,
+            435
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/89aeac61a81fb1e943c371731fed5596c6812ccec8b0f4c2104d430bd4ce1ddc.jpg",
+        "table_caption": [
+            "Table 3: Inference time of our modules. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>MNIST</td><td>CIFAR10</td><td>GTSRB</td><td>CelebA</td></tr><tr><td>time/sample 4.37 μs</td><td>18.64 μs</td><td>18.65 μs</td><td>87.51 μs</td></tr></table>",
+        "bbox": [
+            303,
+            472,
+            692,
+            513
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 ALL-TO-ALL ATTACK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            540,
+            369,
+            554
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Beside the single-target attack scenario, we also verified the effectiveness of WaNet in multi-target scenario, often called all-to-all attack. In this scenario, the input of class $y$ would be targeted into class $c ( y ) = ( y + 1 )$ mod $| C |$ , where $| C |$ is the number of classes. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            608
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2.1 EXPERIMENTAL SETUP ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            622,
+            392,
+            637
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use the same experimental setups as in the single-target scenario, with a small modification. In the attack mode at training, we replace the fixed target label $\\hat { c }$ by $( y + 1 )$ mod $| C |$ . In the attack test at evaluation, we also change the expected label similarly. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            689
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2.2 ATTACK EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            704,
+            383,
+            719
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We conducted attack experiments and reported result in Table 4. While models still achieve stateof-the-art performance on clean data, the attack efficacies slightly decreases. This is due to the fact that the target label now varies from input to input. Though, the lowest attack accuracy is $7 8 . 5 8 \\%$ , which is still harmful to real-life deployment. ",
+        "bbox": [
+            174,
+            729,
+            825,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Similar to all-to-one scenario, we also tested our model with noise mode and recorded the noise accuracy. ",
+        "bbox": [
+            173,
+            791,
+            823,
+            820
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2.3 DEFENSE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            835,
+            400,
+            849
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We repeat the same defense experiments used in the all-to-one scenario. Our backdoor models could also pass all the tests mentioned in Figure 7. ",
+        "bbox": [
+            174,
+            859,
+            823,
+            888
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/10a8bee196006ef8af77259fc5a5828ed0487b3f55356b31463b702689964d7f.jpg",
+        "table_caption": [
+            "Table 4: All-to-all attack result. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Clean Attack</td><td>Noise</td></tr><tr><td>MNIST</td><td>99.44</td><td>95.90 94.34</td></tr><tr><td>CIFAR-10</td><td>94.43</td><td>93.36 91.47</td></tr><tr><td>GTSRB</td><td>99.39</td><td>98.31 98.96</td></tr><tr><td>CelebA</td><td>78.73</td><td>78.58 76.12</td></tr></table>",
+        "bbox": [
+            375,
+            126,
+            617,
+            213
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f367396f6d2069d7ae6303e002dc2f7bba043fbf49a75bf4494886421ccd4c5d.jpg",
+        "image_caption": [
+            "Figure 10: Neural Cleanse against all-to-all scenario. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            227,
+            727,
+            392
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/240110dedb949e789ebf26b2bac7cc82d7809b12aa3f28b0957d007ebe1904ab.jpg",
+        "image_caption": [
+            "Figure 11: Fine-pruning against all-to-all scenario. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            426,
+            826,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f155d1174d16171cb056992f82c5297b7a6cf6d562778244cd94f421ada9778c.jpg",
+        "image_caption": [
+            "Figure 12: STRIP against all-to-all scenario. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            171,
+            597,
+            826,
+            699
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            377,
+            763
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3.1 ADDIONAL IMAGES FOR METIONED BACKDOOR ATTACK METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            776,
+            692,
+            790
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We provide additional examples comparing backdoor images from WaNet and from other attack methods in Fig. 13. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            829
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3.2 EXPERIMENT ON SPECTRAL SIGNATURE DEFENSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            843,
+            576,
+            858
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Tran et al. (2018) proposed a data defense method based on the spectral signature of backdoor training data. Although this data-defense configuration does not match our threat model, we find it useful to verify if our backdoor data have the spectral signature discussed in that paper. We repeated the experiment in the last plot of its Fig. 1, using 5000 clean samples and 1172 backdoor samples generated by WaNet on the CIFAR-10 dataset, which is the same dataset used in the original paper. Fig. 14 plots histograms of the correlations between these samples’ learned representations and their covariance matrix’s top right singular vector. As can be seen, the histograms of the two populations are completely inseparable. Thereby, the backdoor training samples could not be removed from the training dataset using their proposed method. One possible explanation is that the distributional difference between the clean and backdoor correlations in the traditional backdoor methods was the result of the domination of a few backdoor neurons. We do not have such a phenomenon in WaNet, as proved in Fine-Prunning experiments, eliminating the appearance of spectral signature. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/25ebb670000e56552dca7c83822c1e95a8e3ae6ed170efc2d36e723a3c5c3378.jpg",
+        "image_caption": [
+            "Figure 13: Additional images for mentioned backdoor attack methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            97,
+            825,
+            513
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            570,
+            825,
+            683
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "A.3.3 THE STABILITY OF WANET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            696,
+            421,
+            712
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In this section, we verify if WaNet is stable to the variations of the warping field $M$ . We trained 8 WaNet backdoor models, using 8 randomly generated warping fields, in the CIFAR10 dataset. The clean, backdoor, and noise accuracies of the trained models are all stable, as shown in Table 5. ",
+        "bbox": [
+            176,
+            722,
+            825,
+            765
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/adada76305d5190bb2ff588fccf01bbdec894ef8f2da6109c6dca06add2308d1.jpg",
+        "table_caption": [
+            "Table 5: The stability of WaNet on the CIFAR-10 dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Clean</td><td>Backdoor</td><td>Noise</td></tr><tr><td>Accuracy (%)</td><td>94.42 ± 0.08</td><td>99.40 ± 0.21</td><td>93.16 ± 0.43</td></tr></table>",
+        "bbox": [
+            276,
+            803,
+            717,
+            847
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/64b1c0ebfdc1868d7e11bcfaa630829bad191638ceff23bbb1669dfc01d36092.jpg",
+        "image_caption": [
+            "Figure 14: Spectral Signature "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            295,
+            101,
+            700,
+            333
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "A.3.4 ADDITIONAL TRIGGER PATTERNS VISUALIZING THE ROLE OF THE NOISE MODE ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            386,
+            777,
+            400
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "This section further demonstrates the importance of noise mode by providing trigger patterns optimized by Neural Cleanse on more datasets and with more target classes. Fig. 15a and 15b visualize the patterns on MNIST and GTSRB dataset using backdoor models trained for target label 0, similar to Fig. 8a. Fig. 15c, 15d, and 15e provide results on all three datasets but with backdoor models for label 3. As can be seen, the WaNet models without noise mode training return sparse and small patterns, thus easy to be detected by Neural Cleanse. By including that training mode, the optimized patterns are more crowded and approach clean models’ ones. Note that we skip visualizing the results on the CelebA dataset; its patterns optimized on either clean or backdoor models are all too sparse and small for humans to analyze due to subtle differences between human faces. ",
+        "bbox": [
+            173,
+            409,
+            825,
+            535
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/302d62acda83b4f16685d0d77492758ba6c737fa376cd6e835ed81fe8dfa954f.jpg",
+        "image_caption": [
+            "Figure 15: Additional trigger patterns optimized by Neural Cleanse for the target label (small is bad). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            549,
+            789,
+            873
+        ],
+        "page_idx": 15
+    }
+]

parse/train/eoTy4ihL0W/eoTy4ihL0W.md

@@ -0,0 +1,270 @@
+# Evolution Gym: A Large-Scale Benchmark for Evolving Soft Robots
+
+Jagdeep Singh Bhatia MIT CSAIL jagdeep@mit.edu
+
+Holly Jackson   
+MIT CSAIL   
+hjackson@mit.edu
+
+Yunsheng Tian MIT CSAIL yunsheng@csail.mit.edu
+
+Jie Xu MIT CSAIL jiex@csail.mit.edu
+
+Wojciech Matusik MIT CSAIL wojciech@csail.mit.edu
+
+# Abstract
+
+Both the design and control of a robot play equally important roles in its task performance. However, while optimal control is well studied in the machine learning and robotics community, less attention is placed on finding the optimal robot design. This is mainly because co-optimizing design and control in robotics is characterized as a challenging problem, and more importantly, a comprehensive evaluation benchmark for co-optimization does not exist. In this paper, we propose Evolution Gym, the first large-scale benchmark for co-optimizing the design and control of soft robots. In our benchmark, each robot is composed of different types of voxels (e.g., soft, rigid, actuators), resulting in a modular and expressive robot design space. Our benchmark environments span a wide range of tasks, including locomotion on various types of terrains and manipulation. Furthermore, we develop several robot co-evolution algorithms by combining state-of-the-art design optimization methods and deep reinforcement learning techniques. Evaluating the algorithms on our benchmark platform, we observe robots exhibiting increasingly complex behaviors as evolution progresses, with the best evolved designs solving many of our proposed tasks. Additionally, even though robot designs are evolved autonomously from scratch without prior knowledge, they often grow to resemble existing natural creatures while outperforming hand-designed robots. Nevertheless, all tested algorithms fail to find robots that succeed in our hardest environments. This suggests that more advanced algorithms are required to explore the high-dimensional design space and evolve increasingly intelligent robots – an area of research in which we hope Evolution Gym will accelerate progress. Our website with code, environments, documentation, and tutorials is available at http://evogym.csail.mit.edu.
+
+# 1 Introduction
+
+One of the main goals of artificial intelligence is to develop effective approaches for the creation of embodied intelligent systems. Inspired from real organisms, where body structure and brain are two key factors for completing any task in a real environment, a successful intelligent robot typically requires concurrently optimizing its structure design and control mechanism. Such a co-design problem has been a long-standing key challenge in the robotics and machine learning communities. Surprisingly, despite its importance, most previous research works still either only develop complex control algorithms for existing robot structures [1, 2, 17, 30], or conduct co-optimization over robot morphology and control for only a few simple tasks (e.g., running, jumping) [7, 14, 31, 32], especially in the soft body domain. The primary reasons behind the under-exploration of co-design algorithms in sophisticated problems are: (1) the underlying complex bilevel optimization scheme of a co-design algorithm, where the inner control optimization loop leads to a long iteration cycle of the whole optimization process; (2) the lack of a well-established benchmark platform providing the researchers with a suite to evaluate and compare different algorithms.
+
+Digital benchmark environments have proven to be successful at promoting the development of advanced learning techniques via providing a comprehensive evaluation suite to make fair comparisons among different algorithms [5, 11, 36]. However, to our best knowledge, all existing benchmark platforms constrain their domains within control optimization problems, and the space of co-optimization environment suites is still rarely explored.
+
+To fill this gap, in this work we propose Evolution Gym, a large-scale benchmark for evolving both the shape structure and controller of soft robots. The body of each robot in Evolution Gym is composed of various types of primitive building blocks (e.g., soft voxels, rigid voxels, actuator voxels), and the control of the robot includes action signals applied on the actuator voxels. We choose to use this multi-material voxel-based structure as the representation of robot body since it provides a general and universal representation for various categories of robot designs, and at the same time results in a modular and expressive structure design space. We adopt a mass-spring dynamics system [26] with penalty-based frictional contact as the underlining physics engine. Such a light-weight simulator allows the co-design algorithms to significantly reduce the simulation cost and thus accelerate the develop-evaluate iteration cycle [3, 15, 23]. The back-end simulator is fully developed in $\mathrm { C } { + + }$ t o provide further computing efficiency. Another feature of Evolution Gym is its large variety of tasks categorized by varying difficulty levels, which offer an extensive evaluation benchmark for comparing approaches. The benchmark is currently comprised of more than 30 tasks, spanning locomotion on various types of terrains and manipulation. Moreover, Evolution Gym is easy to use. In order to have user-friendly interfaces, we build a Python wrapper outside the $\mathrm { C } { + + }$ simulator and carefully design our APIs off of the well-received APIs of OpenAI Gym with minimum modifications. Evolution Gym will be released fully open-source under the MIT license.
+
+In addition, we develop several baseline algorithms by integrating state-of-the-art design optimization approaches and reinforcement learning techniques. Specifically, in our baseline algorithms, design optimization methods are served in the outer loop to evolve the physical structures of robots and reinforcement learning algorithms are applied in the inner loop to optimize a controller for a given proposed structure design. We conduct extensive experiments to evaluate all baseline algorithms on Evolution Gym. The experiment results demonstrate that intelligent robot designs can be evolved fully autonomously while outperforming hand-designed robots in easier tasks, which reaffirms the necessity of jointly optimizing for both robot structure and control. However, none of the baseline algorithms are capable enough to successfully find robots that complete the task in our hardest environments. Such insufficiency of the existing algorithms suggests the demand for more advanced robot co-design techniques, and we believe our proposed Evolution Gym provides a comprehensive evaluation testbed for robot co-design and unlocks future research in this direction.
+
+In summary, our work has the following key contributions: (i) We propose Evolution Gym, the first large-scale benchmark for soft robot co-design algorithms. (ii) We develop several co-design algorithms by combining state-of-the-art design optimization methods and deep reinforcement learning techniques for control optimization. (iii) The developed algorithms are evaluated and analyzed on our proposed benchmark suite, and the results validate the efficacy of robot co-design while pointing out the failure and limitations of existing algorithms.
+
+# 2 Related work
+
+Robot co-design Co-designing the structure (i.e., body) and control (i.e., brain) of robots is a long-standing key challenge in the robotics community. As the earliest work in this space, Sims [31] represents the structure of a rigid robot as a directed graph and proposes an evolutionary algorithm defined on graphs to optimize the robot design. Subsequently, the co-design of rigid robots is formulated as a graph search problem where more efficient search algorithms are applied [13, 27, 39, 41] to achieve increasingly interesting results. However, with the restriction of having rigid components only, these algorithms are unable to produce optimal or even feasible designs for many challenging tasks where a compliant joint or robot component is required to achieve the goal.
+
+On the contrary, soft components offer much more flexibility to represent arbitrary shapes, making the design of more complex, agile, and high-performing robots possible. Inspired by this, some work has been conducted to co-design robots composed of soft cells. Cheney et al. [7, 8]; Van Diepen and Shea [37]; Corucci et al. [10] propose evolutionary algorithms to co-optimize the structure and control of voxel-based robots. However those algorithms typically parameterize the control as an open-loop periodic sequence of actuation, which prevents robots from learning complex non-periodic tasks such as walking on uneven or varying terrains. Spielberg et al. [32] and Medvet et al. [23] jointly optimize the spatial-varying material parameters and the neural network policy for soft robots but leave the shape of the robot fixed. Our proposed benchmark shares a similar expressive structure design space as Cheney et al. [7], but allows the control to be parameterized by a sophisticated neural network feedback policy. To handle such sophisticated joint optimization of the robot structure and high-dimensional neural network control policy, we develop several baseline co-design algorithms by combining state-of-the-art design optimization strategies and reinforcement learning techniques for control optmization.
+
+Benchmark environments for robotics learning Present research in robotics learning is largely facilitated by emerging benchmark environments. For instance, OpenAI Gym [5], DeepMind Control Suite [36], rllab [11], and Gibson [40] have been developed to benchmark RL algorithms for controlling rigid robots. At the same time, PlasticineLab [16] is specifically designed for soft robot learning. However, the existing benchmark environments are all constructed for learning the control only. To enable the possibility of evolving the structure of a robot, the existing co-design work has to either implement their own testing environment [32, 7, 8, 10, 37], or make substantial changes on the underlying code of the existing control-only environments [29]. The independent development of testing beds requires non-trivial workload, and as a result, existing co-design works mainly focus on evaluating the robot on a few simple tasks such as walking on a flat terrain [7, 6, 8, 37, 32, 23], or swimming along a single direction [9, 39]. An unintended consequence of such independency is an indirect comparison among different algorithms. Evolution Gym fills this gap by presenting a large variety of tasks with different difficulty levels that span from locomotion to manipulation. The proposed benchmark suite can be effectively used to test the generalizability of the algorithms on different tasks, potentially accelerating research in robot co-design.
+
+# 3 Evolution Gym
+
+![](images/f540f0a25bd3a4ab567d628bc5020febbc9d55526a09cf77187a1637e5342b14.jpg)  
+Figure 1: Overview of Evolution Gym and its integration with the co-design algorithms. Evolution Gym is comprised of a back-end soft body simulator (A, B) and task-specific environments (C). A user-customized co-design algorithm can be plugged in to optimize for both robot structure and control through interacting with Evolution Gym on a certain task.
+
+# 3.1 Overview
+
+In this section, we present Evolution Gym, a large-scale benchmark for the co-design of voxel-based soft robots. Evolution Gym is featured by its versatile and expressive multi-material voxel-based structure design space, flexibility of the controller parameterization, wide spectrum of tasks of various difficulty levels, fast back-end soft-body simulation support, and user-friendly Python interfaces.
+
+As shown in the overview in Figure 1, Evolution Gym is comprised of a task-specific environment and a back-end soft-body simulator. The gym suite provides seamless interfaces with a user-defined co-design algorithm. The co-design algorithm typically consists of a design optimizer and a control optimizer. The design optimizer can propose a new robot structure to the control optimizer, then the control optimizer will compute an optimized controller for the given structure through interactions with Evolution Gym and finally return the maximum reward that this robot structure can achieve. In this way, Evolution Gym provides an easy-to-use platform for co-design algorithms to evolve both robot structure and control to optimize for robots’ task performances. Evolution Gym is designed to be the first comprehensive testbed for benchmarking and comparing different co-design algorithms with the hope to facilitate the development of more novel and powerful algorithms in the co-design field.
+
+# 3.2 Multi-material voxel-based representation
+
+Evolution Gym employs a unified multi-material voxel-based representation for all the components in the environment (e.g., robot, terrain, object) as shown in Figure 1A. Specifically, each robot in our gym is composed of rigid voxels, soft voxels, horizontal/vertical actuator voxels, and empty voxels. For terrain and objects, we use the same voxel-based structure but with passive voxel types (i.e., soft/rigid voxels).
+
+We chose a voxel-based representation for three main reasons. First, such a multi-material structure of robots provides a general and universal representation for various categories of robot designs and results in a modular structure design space. Additionally, with just the few voxel types described above, and less than 100 voxels per robot, we are able to construct a wide diversity of morphologies due to the resulting combinatorial robot design space. Even with this simple representation, our designed robots are capable of performing complex motions and completing difficult tasks. Finally, voxel-based robots can be simulated by a fast mass-spring simulation (see section 3.4) which allows our framework to be efficient enough to train robots in a matter of minutes and provides a computationally tractable benchmark for iterating co-design algorithms.
+
+# 3.3 Task representation
+
+Each task in Evolution Gym contains a robot structure proposed by the co-design algorithm, environment specifications (e.g., terrain, object), and a task-related goal (e.g., locomotion or manipulation). The tasks interface with the co-design algorithm through a few key elements including robot structure specification, observation, action, and reward. We introduce each element in detail below.
+
+Robot structure specification As described in Section 3.2, we construct each robot from primitive building blocks arranged on a grid layout. In code, each robot is specified as a material matrix of voxels $\mathcal { M }$ and a connection link list $\mathcal { C }$ . The value of entry $m \in \mathcal { M }$ is a label corresponding to a voxel type from the set {Empty, Rigid, Soft, Horizontal Actuator, Vertical Actuator}. The connection link list $\mathcal { C }$ stores a list of connection pairs of adjacent voxels. The co-design algorithm can update the robot structure in the environment through initialization function with $\mathcal { M }$ and $\mathcal { C }$ as arguments.
+
+Observation The observation is composed in each step to inform the controller of state information of the robot, terrain information of the environment, and goal-relevant information. More specifically, let $N$ be the total number of voxel corner points of the robot. Then the state information of the robot in our tasks is a $( 2 N + 3 )$ -D vector including the relative position of each voxel corner with respect to the center of mass of the robot (2N -D), and the velocity and orientation of center of mass (3-D). To handle complex tasks, specifically those with varying terrain types, an additional observation vector including terrain information is provided. We compile terrain information within a local window of size $2 W$ around the robot into a length- $2 W$ vector observation that describes the terrain’s elevation. Furthermore, goal-related information is offered to inform the controller of the execution status of the current task. This goal-related observation is task-specific and is defined on each task separately. For instance, in manipulation tasks where the robot interacts with some object $O$ , we provide orientation and velocity as well as the position of $O$ ’s center of mass relative to the robot.
+
+Action At each time step, an action vector from the robot’s controller is provided to step Evolution Gym’s simulator. In Evolution Gym, each component of the action vector is associated with an actuator voxel (either horizontal or vertical) of the robot, and instructs a deformation target of that voxel. Specifically, the action value $u$ is within the range [0.6, 1.6], and corresponds to a gradual expansion/contraction of that actuator to $u$ times its rest length.
+
+![](images/053eb8c429dde48e5939018f6c3c0ddcb5a5e3b0be8c8177374baf33de67a0c2.jpg)  
+Figure 2: A visual overview of selected 10 environments from Evolution Gym. A verbal description of tasks is provided in Section 3.5.
+
+Reward Each task is equipped with a reward function measuring the performance of the current robot and the control action. The value of the reward is defined step-wise and is fed back to the agent through step function. The reward function is highly task-specific and should be defined to precisely characterize the robot’s completeness of the task. Please refer to Section 3.5 and Appendix for detailed descriptions of the reward functions on each task.
+
+# 3.4 Simulation engine
+
+We model the dynamics of the underlying simulator as a 2D mass-spring system [26]. This simple, flexible formulation allows us to efficiently model soft robots with a wide range of capabilities in a wide range of environments. The simulation engine is written entirely in $\mathrm { C } { + + }$ . We create Python bindings of our simulator so it seamlessly interfaces with standard learning frameworks.
+
+The simulation represents objects and their environment as a mass-spring system in a grid-like layout (Figure 1B). Objects and their environments are initialized as a set of non-overlapping, connected voxels. On initialization, each voxel is a cross-braced square, but may undergo deformation as the simulation progresses. Each edge acts as an ideal spring obeying Hooke’s law, with a spring constant defined by one of five possible material types. We employ symplectic RK-4 integration to step forward the simulation.
+
+Collision detection is performed using a bounding-box tree structure [12]. Penalty-based contact forces and frictional forces are computed proportionally to the depth of penetration of the corresponding voxels in contact, and are applied on the voxel vertices in the normal and tangential directions of the contact respectively. Please refer to Appendix A for more details of simulation.
+
+# 3.5 Benchmark environment suite
+
+We have developed over 30 unique tasks with Evolution Gym and select 10 tasks here to illustrate the diversity and comprehensiveness of our benchmark task set. All tasks are organized into two categories – locomotion and manipulation – though some tasks are a mix of both. We further classify the tasks into different difficulty levels (i.e., easy, medium, hard) based on the performance of the baseline algorithms (see Section 4) on them. We briefly introduce the selected tasks in this section. For more detailed descriptions and visualizations of the tasks, please refer to our website or Appendix B. It is also worth mentioning that our gym is designed to be extendable and the user can easily create new tasks for their needs.
+
+# 3.5.1 Locomotion tasks
+
+Walker (Easy) This is a common standard task typically considered by previous works where the robot needs to walk on a flat terrain as fast as possible.
+
+Bridge Walker (Easy) In this task, the robot traverses a series of soft “rope” bridges separated by fixed pillars, and similarly as before it needs to maximize its forward speed.
+
+Up Stepper (Medium) The agent walks up a fixed staircase with steps of varying length.
+
+Climber (Medium) The robot must climb two tall fixed walls on each side. The robot is rewarded by its upward climbing speed.
+
+Traverser (Hard) In this hard task, the robot needs to traverse a pit of rigid blocks to get to the other side without sinking into the pit.
+
+# 3.5.2 Object manipulation tasks
+
+Carrier (Easy) The robot needs to catch a small, soft rectangular object initially dropped from above and then carry it along the forward direction. The robot is rewarded by the distance both it and the object have traveled.
+
+Thrower (Medium) The robot throws a soft rectangular box as far as possible without moving itself significantly from its original position.
+
+Beam Slider (Hard) In this task, a beam sits on top of a set of spaced-out floating platforms. The robot is rewarded for moving to the beam and sliding it in the forward direction.
+
+Catcher (Hard) The agent needs to catch a spinning object randomly falling from a high location.
+
+Lifter (Hard) The robot has to manipulate an object and lift it out of a hole.
+
+# 4 Evolving soft robots
+
+Robot evolution/co-design algorithms are formulated as a two-level optimization problem, which involves a design optimization method that evolves physical structures of the robots in the outer loop and a control optimization algorithm that computes an optimized controller for a given robot structure in the inner loop, as illustrated in Algorithm 1. We briefly introduce several instantiations of design optimization methods and control optimization methods in Section 4.1 and 4.2 that we use for evaluation on our benchmark, and more details can be found in Appendix C.
+
+Inputs: Task specification $T$ , number of generations $n$ , population size $p$ .   
+Outputs: The best robot design $D ^ { * }$ and controller $C ^ { * }$ .   
+$S  \emptyset$ // Dataset of robot designs, controllers and reward   
+$D _ { 1 } , . . . , D _ { p } \gets \mathrm { S A M P L E D E S I G N S } ( p )$ // Sample an initial population of robot designs   
+for $i \gets 1$ to $n$ do for $j  1$ to $p$ do $C _ { j } \gets 0 \mathrm { P T I M I Z E C O N T R O L } ( T , D _ { j } )$ // Optimize the controller of given robot design $r _ { j } \gets 1$ EVALUATEREWARD $( T , D _ { j } , C _ { j } )$ // Evaluate the reward of given design and controller $\bar { S }  S \cup \{ ( D _ { j } , C _ { j } , r _ { j } ) \}$ // Update the evaluation result to the dataset $D _ { 1 } , . . . , D _ { p } \gets \mathrm { O P T I M I Z E D E S I G N S } ( S , p ) .$ // Optimize a population of robot designs to evaluate   
+Find the best design $D ^ { * }$ and controller $C ^ { * }$ in dataset $S$ with the maximum reward $r ^ { * }$ .
+
+# 4.1 Design optimization
+
+Design optimization aims at evolving robot structures to maximize the reward under two physical constraints: the body has to be connected, and actuators must exist. In this section, we introduce three instantiations of the design optimization algorithm (OPTIMIZEDESIGN in Algorithm 1).
+
+Genetic algorithm (GA) GAs [24] are widely used in optimizing black-box functions by relying on biologically inspired operators such as mutation, crossover and selection, as demonstrated in previous works on evolving rigid robots [31, 39]. We implement a simple GA using elitism selection and a simple mutation strategy to evolve the population of robot designs. Specifically, in each generation, our elitism selection works by keeping the top $x \%$ of the robots from the current population as survivors and discarding the rest, where $x$ decreases gradually from 60 to 0 over generations. Next, we iteratively sample and mutate one of those survivors with $1 \dot { 0 } \%$ probability of changing each voxel of the robot to create more offsprings. Note that by mutating a voxel type from/to empty voxel, we are able to change the topology of the robot. The crossover operator is not implemented in our genetic algorithm.
+
+Bayesian optimization (BO) BO [20, 25] is a commonly used global optimization method for black-box functions by learning and utilizing a surrogate model, which is usually employed to optimize expensive-to-evaluate functions, including evolving rigid robots in previous works [29, 21]. Specifically, we choose a batch BO algorithm as described in Kandasamy et al. [18] and implemented in the GPyOpt package [4] that supports categorical input data. We use Gaussian processes as the surrogate model, batch Thompson sampling for extracting the acquisition function, and L-BFGS algorithm to optimize the acquisition function. To ensure a fair comparison with other populationbased evolutionary baseline algorithms, the batch size of this algorithm is set equal to the population size of other algorithms.
+
+CPPN-NEAT CPPN-NEAT is the predominant method for evolving soft robot design in previous literature [6, 7, 8]. In this method, the robot design is parameterized by a Compositional Pattern Producing Network (CPPN) [33]. The input to a CPPN is the spatial coordinate of a robot voxel and the output is the type of that voxel. Therefore, by querying the CPPN at all the spatial locations of a robot, we can obtain the type for each voxel to construct a robot. At the same time the NeuroEvolution of Augmenting Topologies (NEAT) algorithm [34] is used to evolve the structure of CPPNs by working as a genetic algorithm with specific mutation, crossover, and selection operators defined on network structures. Our implementation of CPPN-NEAT is based on the PyTorch-NEAT library [28] and the neat-python library [22].
+
+# 4.2 Control optimization
+
+In this section, we introduce the specific control optimization algorithm (OPTIMIZECONTROL in Algorithm 1) that we use in the robot evolution algorithms. In previous works on evolving soft robots, the controller is either encoded as a fixed periodic sequence of actuation [7] or is parameterized as a CPPN that outputs the frequency and phase offset of the periodic actuation for each voxel [8]. However, the periodic pattern of the control prevents robots from learning complex non-periodic tasks such as walking on uneven or varying terrains. Therefore, we use reinforcement learning (RL) [35] to train the controller, making it possible for the soft robots to perform arbitrarily complex tasks in our benchmark. Specifically, we apply a state-of-the-art RL algorithm named Proximal Policy Optimization (PPO) [30] for control optimization of robots, with code implementation given by [19].
+
+# 5 Experiments and results
+
+In this section we present the evaluation results of baseline robot co-design algorithms on 10 selected benchmark tasks described in Section 3.5. The complete evaluation results on all our benchmark tasks can be found in Appendix E.
+
+We develop three baseline algorithms for robot evolution by combing the three design optimization methods in Section 4.1 and PPO for control optimization in Section 4.2. Since the control optimization method is the same for all baseline algorithms, we simply use GA, BO, CPPN-NEAT to denote these three baseline algorithms with different design optimization methods. The evaluations of our baseline algorithms are performed on machines with Intel Xeon CPU $\textcircled { \omega } 2 . 8 0 \mathrm { G H z } ^ { \ast } 8 0$ processors on Google Cloud Platform; GPU is not required. Evaluating one algorithm on a single task usually takes several hours to twenty hours, depending on the number of evaluations, size of population, etc. See Appendix D for more details on hyperparameters of all the experiments.
+
+# 5.1 Comparisons among baseline algorithms
+
+We plot the reward curves of the three baseline algorithms on 10 selected benchmark tasks in Figure 3. There is no single optimal algorithm that performs the best on all tasks, but overall, GA outperforms the other two baseline algorithms. This is surprising because our genetic algorithm is implemented with simple and intuitive operators for mutation and selection without sophisticated mechanisms. Therefore, we believe that with more carefully designed operators, GA has the potential to evolve much more intelligent robots. CPPN-NEAT generally performs well on locomotion tasks, as tested by previous works, but performs poorly on more complex manipulation tasks. This is possibly because
+
+NEAT favors CPPNs with simpler structures, which encourages CPPNs to generate robots with more regular patterns. However, to succeed in complex manipulation tasks, some agile substructures of the robot must evolve, which might only exist in robots with irregular patterns. Finally, it is not surprising that BO performs poorly on most of the tasks because the high-dimensional categorical input parameter space and the noisy evaluation done by RL together pose a challenge to fitting an accurate surrogate model in BO.
+
+![](images/28e51489c7a7245067ab9847f4db9c6e44c41dc3361b5bced78ec9e49378767c.jpg)  
+Figure 3: Performance comparison among baseline algorithms. We plot the best performance of robots that each algorithm has evolved w.r.t. the number of evaluations on each task. All the curves are averaged over 6 different random seeds, and the variance is shown as a shaded region.
+
+![](images/d519dc86079772f8349aceead1bdea35217b757992471ed111590a2dd19d2cf5.jpg)  
+Figure 4: Evolution of robot designs. For each of the three selected tasks, we visualize the population in three different generations. Each column corresponds to one generation for which we show the four top performing robots along with their average reward.
+
+# 5.2 Evolution analysis
+
+In Figure 4 we visualize the top four robots in three different generations on training the genetic algorithm for the Carrier, Lifter, and Bridge Walker task. We also show the average reward these designs achieve.
+
+In the carrier task, the robot must catch an object that falls from above and then carry that object as far as possible. Therefore, a successful design for this task achieves two main goals 1) allowing the robot to catch and hold the object securely 2) allowing the robot to move fast. We observe that robots with a block-holding mechanism and with legs are selected for in the top survivors of generation 1 (randomly initialized). As evolution progresses, these structures become increasingly optimized. Specifically, in later generations, the robots’ structures allow them to walk faster while still preventing the block from falling.
+
+![](images/8ffffcf3f893ce0f4598ad550be5790e071afbff144f94f4526036d0285a0e16.jpg)  
+Figure 5: Comparison between algorithm-optimized robots and hand designed robots on three tasks. In each task, we visualize one robot optimized by the algorithm and several hand-designed robots.
+
+A similar comparison pattern can be seen in the Lifter task, where the algorithm learns a parallel gripper-like shape underneath the robot in order to manipulate an object. Unlike in the carrier task, the design structures that the algorithm generates are not prominently found in the initial generation. Finally, these patterns are echoed in the Bridge Walker task. Here the robot learns to evolve a large front foot to maximize its surface area and friction force to best walk across the soft rope bridge.
+
+# 5.3 Comparison against hand-designed robots
+
+We compare the performances of robots optimized by algorithm and the hand designed robots on several tasks to show the necessity of a co-design algorithm (Figure 5). The structure of the hand designed robots are bio-inspired and manually constructed according to our best intuition, and their control are optimized by PPO.
+
+For every task, the hand designed robots are outperformed by at least one algorithm (usually more). For instance, for the Climber task we tested numerous natural robot designs. However, none of them successfully climbed very far. The issue with our designs is that we could not find the right trade off between getting traction on the wall, and accelerating upwards. The genetic algorithm, however, is able to find this balance. It develops leg-like structures that help the robot make forward progress, as well as a long flat back that maximizes contact/frictional forces with the wall. Additionally, the genetic algorithm selects for having a hole in the center of its body, which helps it achieve a certain optimized walking motion.
+
+For other tasks, the performance between the hand designed robots and the robots produced by the algorithms is quite comparable. This is the case with the Carrier robots, as a very natural hand-designed Carrier robot performs almost as well as the best optimized robots produced by the design-optimization algorithms.
+
+In the final case, there are tasks where neither a hand designed nor robot produced by the algorithm could achieve satisfying performance. One such environment is the Beam Slider environment. For this task, many of the hand design robots fail to even achieve the first part of the goal and position themselves underneath the beam. While there is one robot produced by the genetic algorithm that does slide the beam across several pegs, from visual observation we believe it comes nowhere close to exhibiting the optimal behavior in this environment. This suggests that further work is needed in designing co-optimization algorithms that can complete these hard tasks.
+
+# 6 Conclusion and future work
+
+In this paper we proposed Evolution Gym, the first large-scale benchmark for evolving the structure and control of soft robots. Through the wide spectrum of tasks in Evolution Gym, we systematically studied the performance of current state-of-the-art co-design algorithms. As a result, we observed how intelligent robots could be evolved autonomously from scratch yet still be capable of accomplishing some surprisingly complex tasks. We also discovered the limitations of existing techniques for evolving more intelligent embodied systems.
+
+There are several potential directions to be explored in the future. First, with the help of our proposed benchmark, it is desirable to develop more advanced co-design algorithms to solve the difficult tasks which existing methods cannot address. Our currently implemented baseline algorithms share a bi-level optimization routine where the design optimization is in the outer loop while the control optimization is in the inner loop. However, Evolution Gym is agnostic to the specific training procedure used. As a result, some ideas for future work using our framework could include concurrently co-optimizing the design and control, neuroevolution algorithms, morphogenetic development, gradient-based methods for design optimization, or algorithms with decentralized controllers.
+
+Second, a robot will be considered more successful if it can perform multiple tasks. Our benchmark suite naturally provides a comprehensive set of tasks and can potentially promote more exciting research work about multi-task or multi-objective robot co-design algorithms.
+
+Another consideration is the specific morphological encodings used by the codesign algorithms as more intelligent encodings could lead to better performance. For instance, [38] analyzes the strengths and weaknesses of different morphological encodings. Our baseline algorithms use a direct encoding and CPPN but exploring other encoding representations remains interesting future work.
+
+Finally, since tasks in Evolution Gym are currently limited to either locomotion or manipulation, we plan to further extend Evolution Gym to additional task categories such as flying or swimming by incorporating new simulation capabilities.
+
+Overall, we believe our carefully-designed benchmarking tool fills an important missing piece in research in soft robotics and robotic evolution algorithms. Armed with the flexible and expressive framework Evolution Gym provides, we are optimistic that future researchers will use Evolution Gym as a standard test bed to improve co-design methods and evolve more intelligent robots.
+
+# Societal Impact
+
+We regard this work as a very preliminary piece of research in the field of soft robot co-design, and therefore think that we are still far away from causing harm to society. However, we can definitely foresee some problems if this technology were to be applied in the real world on a large scale. For instance, this work may inspire the automatic design of real biological creatures in which serious ethical issues exist. Additionally, since the users have full control over the reward design when customizing the benchmark environments, they could specify pernicious goals and encourage the co-design algorithm to produce more biased results.
+
+# Acknowledgments and Disclosure of Funding
+
+We thank Tao Du and the anonymous reviewers for their helpful comments in revising the paper. This work is supported by the Defense Advanced Research Projects Agency (FA8750-20-C-0075).
+
+# References
+
+[1] Ilge Akkaya, Marcin Andrychowicz, Maciek Chociej, Mateusz Litwin, Bob McGrew, Arthur Petron, Alex Paino, Matthias Plappert, Glenn Powell, Raphael Ribas, et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019.
+
+[2] OpenAI: Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020.   
+[3] Jacob Austin, Rafael Corrales-Fatou, Sofia Wyetzner, and Hod Lipson. Titan: A parallel asynchronous library for multi-agent and soft-body robotics using nvidia cuda. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 7754–7760, 2020.   
+[4] The GPyOpt authors. GPyOpt: A bayesian optimization framework in python. http:// github.com/SheffieldML/GPyOpt, 2016.   
+[5] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.   
+[6] Nicholas Cheney, Jeff Clune, and Hod Lipson. Evolved electrophysiological soft robots. In Artificial Life Conference Proceedings 14, pages 222–229. MIT Press, 2014.   
+[7] Nick Cheney, Robert MacCurdy, Jeff Clune, and Hod Lipson. Unshackling evolution: Evolving soft robots with multiple materials and a powerful generative encoding. SIGEVOlution, 7(1):11–23, August 2014.   
+[8] Francesco Corucci, Nick Cheney, Francesco Giorgio-Serchi, Josh Bongard, and Cecilia Laschi. Evolving soft locomotion in aquatic and terrestrial environments: effects of material properties and environmental transitions, 2017.   
+[9] Francesco Corucci, Nick Cheney, Francesco Giorgio-Serchi, Josh Bongard, and Cecilia Laschi. Evolving soft locomotion in aquatic and terrestrial environments: effects of material properties and environmental transitions. Soft robotics, 5(4):475–495, 2018.   
+[10] Francesco Corucci, Nick Cheney, Hod Lipson, Cecilia Laschi, and Josh Bongard. Evolving swimming soft-bodied creatures. In ALIFE XV, The Fifteenth International Conference on the Synthesis and Simulation of Living Systems, Late Breaking Proceedings, volume 6, 2016.   
+[11] Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International conference on machine learning, pages 1329–1338. PMLR, 2016.   
+[12] Christer Ericson. Real-time collision detection. CRC Press, 2004.   
+[13] David Ha. Reinforcement learning for improving agent design. Artificial life, 25(4):352–365, 2019.   
+[14] Donald J Hejna III, Pieter Abbeel, and Lerrel Pinto. Task-agnostic morphology evolution. arXiv preprint arXiv:2102.13100, 2021.   
+[15] Jonathan Hiller and Hod Lipson. Dynamic simulation of soft multimaterial 3d-printed objects. Soft robotics, 1(1):88–101, 2014.   
+[16] Zhiao Huang, Yuanming Hu, Tao Du, Siyuan Zhou, Hao Su, Joshua B. Tenenbaum, and Chuang Gan. Plasticinelab: A soft-body manipulation benchmark with differentiable physics, 2021.   
+[17] Jemin Hwangbo, Joonho Lee, Alexey Dosovitskiy, Dario Bellicoso, Vassilios Tsounis, Vladlen Koltun, and Marco Hutter. Learning agile and dynamic motor skills for legged robots. Science Robotics, 4(26), 2019.   
+[18] Kirthevasan Kandasamy, Akshay Krishnamurthy, Jeff Schneider, and Barnabás Póczos. Parallelised bayesian optimisation via thompson sampling. In International Conference on Artificial Intelligence and Statistics, pages 133–142. PMLR, 2018.   
+[19] Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https:// github.com/ikostrikov/pytorch-a2c-ppo-acktr-gail, 2018.   
+[20] Harold J Kushner. A new method of locating the maximum point of an arbitrary multipeak curve in the presence of noise. 1964.   
+[21] Thomas Liao, Grant Wang, Brian Yang, Rene Lee, Kristofer Pister, Sergey Levine, and Roberto Calandra. Data-efficient learning of morphology and controller for a microrobot. In 2019 International Conference on Robotics and Automation (ICRA), pages 2488–2494. IEEE, 2019.   
+[22] Alan McIntyre, Matt Kallada, Cesar G. Miguel, and Carolina Feher da Silva. neat-python. https://github.com/CodeReclaimers/neat-python.   
+[23] Eric Medvet, Alberto Bartoli, Andrea De Lorenzo, and Stefano Seriani. 2d-vsr-sim: A simulation tool for the optimization of 2-d voxel-based soft robots. SoftwareX, 12:100573, 2020.   
+[24] Zbigniew Michalewicz. Genetic algorithms $^ +$ data structures $=$ evolution programs. Springer Science & Business Media, 2013.   
+[25] J. Mockus. On bayesian methods for seeking the extremum. In G. I. Marchuk, editor, ˇ Optimization Techniques IFIP Technical Conference Novosibirsk, July 1–7, 1974, pages 400–404, Berlin, Heidelberg, 1975. Springer Berlin Heidelberg.   
+[26] Andrew Nealen, Matthias Müller, Richard Keiser, Eddy Boxerman, and Mark Carlson. Physically based deformable models in computer graphics. In Computer graphics forum, volume 25, pages 809–836. Wiley Online Library, 2006.   
+[27] Deepak Pathak, Chris Lu, Trevor Darrell, Phillip Isola, and Alexei A Efros. Learning to control self-assembling morphologies: a study of generalization via modularity. arXiv preprint arXiv:1902.05546, 2019.   
+[28] Uber Research. pytorch-neat. https://github.com/uber-research/PyTorch-NEAT.   
+[29] Charles Schaff, David Yunis, Ayan Chakrabarti, and Matthew R Walter. Jointly learning to construct and control agents using deep reinforcement learning. In 2019 International Conference on Robotics and Automation (ICRA), pages 9798–9805. IEEE, 2019.   
+[30] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms, 2017.   
+[31] Karl Sims. Evolving virtual creatures. In Proceedings of the 21st annual conference on Computer graphics and interactive techniques, pages 15–22, 1994.   
+[32] Andrew Spielberg, Allan Zhao, Yuanming Hu, Tao Du, Wojciech Matusik, and Daniela Rus. Learning-in-the-loop optimization: End-to-end control and co-design of soft robots through learned deep latent representations. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   
+[33] Kenneth O Stanley. Compositional pattern producing networks: A novel abstraction of development. Genetic programming and evolvable machines, 8(2):131–162, 2007.   
+[34] Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.   
+[35] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   
+[36] Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy Lillicrap, and Martin Riedmiller. Deepmind control suite, 2018.   
+[37] Merel Van Diepen and Kristina Shea. A spatial grammar method for the computational design synthesis of virtual soft locomotion robots. Journal of Mechanical Design, 141(10), 2019.   
+[38] Frank Veenstra and Kyrre Glette. How different encodings affect performance and diversification when evolving the morphology and control of 2d virtual creatures. In Artificial Life Conference Proceedings, pages 592–601. MIT Press, 2020.   
+[39] Tingwu Wang, Yuhao Zhou, Sanja Fidler, and Jimmy Ba. Neural graph evolution: Towards efficient automatic robot design, 2019.   
+[40] Fei Xia, Amir R Zamir, Zhiyang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson env: Real-world perception for embodied agents. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 9068–9079, 2018.   
+[41] Allan Zhao, Jie Xu, Mina Konakovic-Lukovi ´ c, Josephine Hughes, Andrew Spielberg, Daniela ´ Rus, and Wojciech Matusik. Robogrammar: Graph grammar for terrain-optimized robot design. ACM Trans. Graph., 39(6), November 2020.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes] See Section 6.   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 6.   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The URL is presented in the abstract.   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix D.   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We ran experiments with multiple random seeds and reported error bars. See Section 5.   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Section 5.
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes] The existing code implementation for our baseline algorithms are cited in Section 4.   
+(b) Did you mention the license of the assets? [Yes] This benchmark platform will be released under the MIT license. See Section 1.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] The URL is presented in the abstract.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/eoTy4ihL0W/eoTy4ihL0W_content_list.json

@@ -0,0 +1,1267 @@
+[
+    {
+        "type": "text",
+        "text": "Evolution Gym: A Large-Scale Benchmark for Evolving Soft Robots ",
+        "text_level": 1,
+        "bbox": [
+            217,
+            122,
+            781,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jagdeep Singh Bhatia MIT CSAIL jagdeep@mit.edu ",
+        "bbox": [
+            210,
+            226,
+            367,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Holly Jackson   \nMIT CSAIL   \nhjackson@mit.edu ",
+        "bbox": [
+            408,
+            226,
+            550,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yunsheng Tian MIT CSAIL yunsheng@csail.mit.edu ",
+        "bbox": [
+            593,
+            226,
+            784,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jie Xu MIT CSAIL jiex@csail.mit.edu ",
+        "bbox": [
+            272,
+            289,
+            429,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wojciech Matusik MIT CSAIL wojciech@csail.mit.edu ",
+        "bbox": [
+            534,
+            289,
+            725,
+            332
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            367,
+            535,
+            383
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Both the design and control of a robot play equally important roles in its task performance. However, while optimal control is well studied in the machine learning and robotics community, less attention is placed on finding the optimal robot design. This is mainly because co-optimizing design and control in robotics is characterized as a challenging problem, and more importantly, a comprehensive evaluation benchmark for co-optimization does not exist. In this paper, we propose Evolution Gym, the first large-scale benchmark for co-optimizing the design and control of soft robots. In our benchmark, each robot is composed of different types of voxels (e.g., soft, rigid, actuators), resulting in a modular and expressive robot design space. Our benchmark environments span a wide range of tasks, including locomotion on various types of terrains and manipulation. Furthermore, we develop several robot co-evolution algorithms by combining state-of-the-art design optimization methods and deep reinforcement learning techniques. Evaluating the algorithms on our benchmark platform, we observe robots exhibiting increasingly complex behaviors as evolution progresses, with the best evolved designs solving many of our proposed tasks. Additionally, even though robot designs are evolved autonomously from scratch without prior knowledge, they often grow to resemble existing natural creatures while outperforming hand-designed robots. Nevertheless, all tested algorithms fail to find robots that succeed in our hardest environments. This suggests that more advanced algorithms are required to explore the high-dimensional design space and evolve increasingly intelligent robots – an area of research in which we hope Evolution Gym will accelerate progress. Our website with code, environments, documentation, and tutorials is available at http://evogym.csail.mit.edu. ",
+        "bbox": [
+            232,
+            400,
+            766,
+            729
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            310,
+            775
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One of the main goals of artificial intelligence is to develop effective approaches for the creation of embodied intelligent systems. Inspired from real organisms, where body structure and brain are two key factors for completing any task in a real environment, a successful intelligent robot typically requires concurrently optimizing its structure design and control mechanism. Such a co-design problem has been a long-standing key challenge in the robotics and machine learning communities. Surprisingly, despite its importance, most previous research works still either only develop complex control algorithms for existing robot structures [1, 2, 17, 30], or conduct co-optimization over robot morphology and control for only a few simple tasks (e.g., running, jumping) [7, 14, 31, 32], especially in the soft body domain. The primary reasons behind the under-exploration of co-design algorithms in sophisticated problems are: (1) the underlying complex bilevel optimization scheme of a co-design algorithm, where the inner control optimization loop leads to a long iteration cycle of the whole optimization process; (2) the lack of a well-established benchmark platform providing the researchers with a suite to evaluate and compare different algorithms. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            825,
+            160
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Digital benchmark environments have proven to be successful at promoting the development of advanced learning techniques via providing a comprehensive evaluation suite to make fair comparisons among different algorithms [5, 11, 36]. However, to our best knowledge, all existing benchmark platforms constrain their domains within control optimization problems, and the space of co-optimization environment suites is still rarely explored. ",
+        "bbox": [
+            174,
+            167,
+            825,
+            237
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To fill this gap, in this work we propose Evolution Gym, a large-scale benchmark for evolving both the shape structure and controller of soft robots. The body of each robot in Evolution Gym is composed of various types of primitive building blocks (e.g., soft voxels, rigid voxels, actuator voxels), and the control of the robot includes action signals applied on the actuator voxels. We choose to use this multi-material voxel-based structure as the representation of robot body since it provides a general and universal representation for various categories of robot designs, and at the same time results in a modular and expressive structure design space. We adopt a mass-spring dynamics system [26] with penalty-based frictional contact as the underlining physics engine. Such a light-weight simulator allows the co-design algorithms to significantly reduce the simulation cost and thus accelerate the develop-evaluate iteration cycle [3, 15, 23]. The back-end simulator is fully developed in $\\mathrm { C } { + + }$ t o provide further computing efficiency. Another feature of Evolution Gym is its large variety of tasks categorized by varying difficulty levels, which offer an extensive evaluation benchmark for comparing approaches. The benchmark is currently comprised of more than 30 tasks, spanning locomotion on various types of terrains and manipulation. Moreover, Evolution Gym is easy to use. In order to have user-friendly interfaces, we build a Python wrapper outside the $\\mathrm { C } { + + }$ simulator and carefully design our APIs off of the well-received APIs of OpenAI Gym with minimum modifications. Evolution Gym will be released fully open-source under the MIT license. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In addition, we develop several baseline algorithms by integrating state-of-the-art design optimization approaches and reinforcement learning techniques. Specifically, in our baseline algorithms, design optimization methods are served in the outer loop to evolve the physical structures of robots and reinforcement learning algorithms are applied in the inner loop to optimize a controller for a given proposed structure design. We conduct extensive experiments to evaluate all baseline algorithms on Evolution Gym. The experiment results demonstrate that intelligent robot designs can be evolved fully autonomously while outperforming hand-designed robots in easier tasks, which reaffirms the necessity of jointly optimizing for both robot structure and control. However, none of the baseline algorithms are capable enough to successfully find robots that complete the task in our hardest environments. Such insufficiency of the existing algorithms suggests the demand for more advanced robot co-design techniques, and we believe our proposed Evolution Gym provides a comprehensive evaluation testbed for robot co-design and unlocks future research in this direction. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            650
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In summary, our work has the following key contributions: (i) We propose Evolution Gym, the first large-scale benchmark for soft robot co-design algorithms. (ii) We develop several co-design algorithms by combining state-of-the-art design optimization methods and deep reinforcement learning techniques for control optimization. (iii) The developed algorithms are evaluated and analyzed on our proposed benchmark suite, and the results validate the efficacy of robot co-design while pointing out the failure and limitations of existing algorithms. ",
+        "bbox": [
+            174,
+            656,
+            825,
+            739
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related work ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            765,
+            316,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Robot co-design Co-designing the structure (i.e., body) and control (i.e., brain) of robots is a long-standing key challenge in the robotics community. As the earliest work in this space, Sims [31] represents the structure of a rigid robot as a directed graph and proposes an evolutionary algorithm defined on graphs to optimize the robot design. Subsequently, the co-design of rigid robots is formulated as a graph search problem where more efficient search algorithms are applied [13, 27, 39, 41] to achieve increasingly interesting results. However, with the restriction of having rigid components only, these algorithms are unable to produce optimal or even feasible designs for many challenging tasks where a compliant joint or robot component is required to achieve the goal. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On the contrary, soft components offer much more flexibility to represent arbitrary shapes, making the design of more complex, agile, and high-performing robots possible. Inspired by this, some work has been conducted to co-design robots composed of soft cells. Cheney et al. [7, 8]; Van Diepen and Shea [37]; Corucci et al. [10] propose evolutionary algorithms to co-optimize the structure and control of voxel-based robots. However those algorithms typically parameterize the control as an open-loop periodic sequence of actuation, which prevents robots from learning complex non-periodic tasks such as walking on uneven or varying terrains. Spielberg et al. [32] and Medvet et al. [23] jointly optimize the spatial-varying material parameters and the neural network policy for soft robots but leave the shape of the robot fixed. Our proposed benchmark shares a similar expressive structure design space as Cheney et al. [7], but allows the control to be parameterized by a sophisticated neural network feedback policy. To handle such sophisticated joint optimization of the robot structure and high-dimensional neural network control policy, we develop several baseline co-design algorithms by combining state-of-the-art design optimization strategies and reinforcement learning techniques for control optmization. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            285
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Benchmark environments for robotics learning Present research in robotics learning is largely facilitated by emerging benchmark environments. For instance, OpenAI Gym [5], DeepMind Control Suite [36], rllab [11], and Gibson [40] have been developed to benchmark RL algorithms for controlling rigid robots. At the same time, PlasticineLab [16] is specifically designed for soft robot learning. However, the existing benchmark environments are all constructed for learning the control only. To enable the possibility of evolving the structure of a robot, the existing co-design work has to either implement their own testing environment [32, 7, 8, 10, 37], or make substantial changes on the underlying code of the existing control-only environments [29]. The independent development of testing beds requires non-trivial workload, and as a result, existing co-design works mainly focus on evaluating the robot on a few simple tasks such as walking on a flat terrain [7, 6, 8, 37, 32, 23], or swimming along a single direction [9, 39]. An unintended consequence of such independency is an indirect comparison among different algorithms. Evolution Gym fills this gap by presenting a large variety of tasks with different difficulty levels that span from locomotion to manipulation. The proposed benchmark suite can be effectively used to test the generalizability of the algorithms on different tasks, potentially accelerating research in robot co-design. ",
+        "bbox": [
+            173,
+            291,
+            825,
+            498
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Evolution Gym ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            333,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/f540f0a25bd3a4ab567d628bc5020febbc9d55526a09cf77187a1637e5342b14.jpg",
+        "image_caption": [
+            "Figure 1: Overview of Evolution Gym and its integration with the co-design algorithms. Evolution Gym is comprised of a back-end soft body simulator (A, B) and task-specific environments (C). A user-customized co-design algorithm can be plugged in to optimize for both robot structure and control through interacting with Evolution Gym on a certain task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            556,
+            807,
+            742
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Overview ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            828,
+            279,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present Evolution Gym, a large-scale benchmark for the co-design of voxel-based soft robots. Evolution Gym is featured by its versatile and expressive multi-material voxel-based structure design space, flexibility of the controller parameterization, wide spectrum of tasks of various difficulty levels, fast back-end soft-body simulation support, and user-friendly Python interfaces. ",
+        "bbox": [
+            174,
+            856,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As shown in the overview in Figure 1, Evolution Gym is comprised of a task-specific environment and a back-end soft-body simulator. The gym suite provides seamless interfaces with a user-defined co-design algorithm. The co-design algorithm typically consists of a design optimizer and a control optimizer. The design optimizer can propose a new robot structure to the control optimizer, then the control optimizer will compute an optimized controller for the given structure through interactions with Evolution Gym and finally return the maximum reward that this robot structure can achieve. In this way, Evolution Gym provides an easy-to-use platform for co-design algorithms to evolve both robot structure and control to optimize for robots’ task performances. Evolution Gym is designed to be the first comprehensive testbed for benchmarking and comparing different co-design algorithms with the hope to facilitate the development of more novel and powerful algorithms in the co-design field. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            242
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 Multi-material voxel-based representation ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            266,
+            506,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Evolution Gym employs a unified multi-material voxel-based representation for all the components in the environment (e.g., robot, terrain, object) as shown in Figure 1A. Specifically, each robot in our gym is composed of rigid voxels, soft voxels, horizontal/vertical actuator voxels, and empty voxels. For terrain and objects, we use the same voxel-based structure but with passive voxel types (i.e., soft/rigid voxels). ",
+        "bbox": [
+            174,
+            294,
+            825,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We chose a voxel-based representation for three main reasons. First, such a multi-material structure of robots provides a general and universal representation for various categories of robot designs and results in a modular structure design space. Additionally, with just the few voxel types described above, and less than 100 voxels per robot, we are able to construct a wide diversity of morphologies due to the resulting combinatorial robot design space. Even with this simple representation, our designed robots are capable of performing complex motions and completing difficult tasks. Finally, voxel-based robots can be simulated by a fast mass-spring simulation (see section 3.4) which allows our framework to be efficient enough to train robots in a matter of minutes and provides a computationally tractable benchmark for iterating co-design algorithms. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            494
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Task representation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            349,
+            532
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each task in Evolution Gym contains a robot structure proposed by the co-design algorithm, environment specifications (e.g., terrain, object), and a task-related goal (e.g., locomotion or manipulation). The tasks interface with the co-design algorithm through a few key elements including robot structure specification, observation, action, and reward. We introduce each element in detail below. ",
+        "bbox": [
+            174,
+            545,
+            825,
+            601
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Robot structure specification As described in Section 3.2, we construct each robot from primitive building blocks arranged on a grid layout. In code, each robot is specified as a material matrix of voxels $\\mathcal { M }$ and a connection link list $\\mathcal { C }$ . The value of entry $m \\in \\mathcal { M }$ is a label corresponding to a voxel type from the set {Empty, Rigid, Soft, Horizontal Actuator, Vertical Actuator}. The connection link list $\\mathcal { C }$ stores a list of connection pairs of adjacent voxels. The co-design algorithm can update the robot structure in the environment through initialization function with $\\mathcal { M }$ and $\\mathcal { C }$ as arguments. ",
+        "bbox": [
+            174,
+            607,
+            825,
+            690
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Observation The observation is composed in each step to inform the controller of state information of the robot, terrain information of the environment, and goal-relevant information. More specifically, let $N$ be the total number of voxel corner points of the robot. Then the state information of the robot in our tasks is a $( 2 N + 3 )$ -D vector including the relative position of each voxel corner with respect to the center of mass of the robot (2N -D), and the velocity and orientation of center of mass (3-D). To handle complex tasks, specifically those with varying terrain types, an additional observation vector including terrain information is provided. We compile terrain information within a local window of size $2 W$ around the robot into a length- $2 W$ vector observation that describes the terrain’s elevation. Furthermore, goal-related information is offered to inform the controller of the execution status of the current task. This goal-related observation is task-specific and is defined on each task separately. For instance, in manipulation tasks where the robot interacts with some object $O$ , we provide orientation and velocity as well as the position of $O$ ’s center of mass relative to the robot. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            863
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Action At each time step, an action vector from the robot’s controller is provided to step Evolution Gym’s simulator. In Evolution Gym, each component of the action vector is associated with an actuator voxel (either horizontal or vertical) of the robot, and instructs a deformation target of that voxel. Specifically, the action value $u$ is within the range [0.6, 1.6], and corresponds to a gradual expansion/contraction of that actuator to $u$ times its rest length. ",
+        "bbox": [
+            176,
+            869,
+            823,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/053eb8c429dde48e5939018f6c3c0ddcb5a5e3b0be8c8177374baf33de67a0c2.jpg",
+        "image_caption": [
+            "Figure 2: A visual overview of selected 10 environments from Evolution Gym. A verbal description of tasks is provided in Section 3.5. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            90,
+            790,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            343,
+            823,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reward Each task is equipped with a reward function measuring the performance of the current robot and the control action. The value of the reward is defined step-wise and is fed back to the agent through step function. The reward function is highly task-specific and should be defined to precisely characterize the robot’s completeness of the task. Please refer to Section 3.5 and Appendix for detailed descriptions of the reward functions on each task. ",
+        "bbox": [
+            174,
+            377,
+            825,
+            446
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 Simulation engine ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            338,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We model the dynamics of the underlying simulator as a 2D mass-spring system [26]. This simple, flexible formulation allows us to efficiently model soft robots with a wide range of capabilities in a wide range of environments. The simulation engine is written entirely in $\\mathrm { C } { + + }$ . We create Python bindings of our simulator so it seamlessly interfaces with standard learning frameworks. ",
+        "bbox": [
+            174,
+            489,
+            825,
+            545
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The simulation represents objects and their environment as a mass-spring system in a grid-like layout (Figure 1B). Objects and their environments are initialized as a set of non-overlapping, connected voxels. On initialization, each voxel is a cross-braced square, but may undergo deformation as the simulation progresses. Each edge acts as an ideal spring obeying Hooke’s law, with a spring constant defined by one of five possible material types. We employ symplectic RK-4 integration to step forward the simulation. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            636
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Collision detection is performed using a bounding-box tree structure [12]. Penalty-based contact forces and frictional forces are computed proportionally to the depth of penetration of the corresponding voxels in contact, and are applied on the voxel vertices in the normal and tangential directions of the contact respectively. Please refer to Appendix A for more details of simulation. ",
+        "bbox": [
+            174,
+            642,
+            825,
+            698
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 Benchmark environment suite ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            712,
+            423,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We have developed over 30 unique tasks with Evolution Gym and select 10 tasks here to illustrate the diversity and comprehensiveness of our benchmark task set. All tasks are organized into two categories – locomotion and manipulation – though some tasks are a mix of both. We further classify the tasks into different difficulty levels (i.e., easy, medium, hard) based on the performance of the baseline algorithms (see Section 4) on them. We briefly introduce the selected tasks in this section. For more detailed descriptions and visualizations of the tasks, please refer to our website or Appendix B. It is also worth mentioning that our gym is designed to be extendable and the user can easily create new tasks for their needs. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5.1 Locomotion tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            859,
+            348,
+            873
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Walker (Easy) This is a common standard task typically considered by previous works where the robot needs to walk on a flat terrain as fast as possible. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Bridge Walker (Easy) In this task, the robot traverses a series of soft “rope” bridges separated by fixed pillars, and similarly as before it needs to maximize its forward speed. ",
+        "bbox": [
+            171,
+            90,
+            823,
+            119
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Up Stepper (Medium) The agent walks up a fixed staircase with steps of varying length. ",
+        "bbox": [
+            173,
+            126,
+            754,
+            140
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Climber (Medium) The robot must climb two tall fixed walls on each side. The robot is rewarded by its upward climbing speed. ",
+        "bbox": [
+            174,
+            146,
+            825,
+            175
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Traverser (Hard) In this hard task, the robot needs to traverse a pit of rigid blocks to get to the other side without sinking into the pit. ",
+        "bbox": [
+            173,
+            180,
+            823,
+            209
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.5.2 Object manipulation tasks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            408,
+            239
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Carrier (Easy) The robot needs to catch a small, soft rectangular object initially dropped from above and then carry it along the forward direction. The robot is rewarded by the distance both it and the object have traveled. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            289
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Thrower (Medium) The robot throws a soft rectangular box as far as possible without moving itself significantly from its original position. ",
+        "bbox": [
+            174,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Beam Slider (Hard) In this task, a beam sits on top of a set of spaced-out floating platforms. The robot is rewarded for moving to the beam and sliding it in the forward direction. ",
+        "bbox": [
+            173,
+            330,
+            821,
+            358
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Catcher (Hard) The agent needs to catch a spinning object randomly falling from a high location. ",
+        "bbox": [
+            174,
+            364,
+            813,
+            380
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Lifter (Hard) The robot has to manipulate an object and lift it out of a hole. ",
+        "bbox": [
+            176,
+            385,
+            669,
+            400
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 Evolving soft robots ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            419,
+            372,
+            436
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Robot evolution/co-design algorithms are formulated as a two-level optimization problem, which involves a design optimization method that evolves physical structures of the robots in the outer loop and a control optimization algorithm that computes an optimized controller for a given robot structure in the inner loop, as illustrated in Algorithm 1. We briefly introduce several instantiations of design optimization methods and control optimization methods in Section 4.1 and 4.2 that we use for evaluation on our benchmark, and more details can be found in Appendix C. ",
+        "bbox": [
+            173,
+            450,
+            825,
+            534
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Inputs: Task specification $T$ , number of generations $n$ , population size $p$ .   \nOutputs: The best robot design $D ^ { * }$ and controller $C ^ { * }$ .   \n$S  \\emptyset$ // Dataset of robot designs, controllers and reward   \n$D _ { 1 } , . . . , D _ { p } \\gets \\mathrm { S A M P L E D E S I G N S } ( p )$ // Sample an initial population of robot designs   \nfor $i \\gets 1$ to $n$ do for $j  1$ to $p$ do $C _ { j } \\gets 0 \\mathrm { P T I M I Z E C O N T R O L } ( T , D _ { j } )$ // Optimize the controller of given robot design $r _ { j } \\gets 1$ EVALUATEREWARD $( T , D _ { j } , C _ { j } )$ // Evaluate the reward of given design and controller $\\bar { S }  S \\cup \\{ ( D _ { j } , C _ { j } , r _ { j } ) \\}$ // Update the evaluation result to the dataset $D _ { 1 } , . . . , D _ { p } \\gets \\mathrm { O P T I M I Z E D E S I G N S } ( S , p ) .$ // Optimize a population of robot designs to evaluate   \nFind the best design $D ^ { * }$ and controller $C ^ { * }$ in dataset $S$ with the maximum reward $r ^ { * }$ . ",
+        "bbox": [
+            179,
+            566,
+            823,
+            722
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 Design optimization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            739,
+            352,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Design optimization aims at evolving robot structures to maximize the reward under two physical constraints: the body has to be connected, and actuators must exist. In this section, we introduce three instantiations of the design optimization algorithm (OPTIMIZEDESIGN in Algorithm 1). ",
+        "bbox": [
+            174,
+            766,
+            823,
+            809
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Genetic algorithm (GA) GAs [24] are widely used in optimizing black-box functions by relying on biologically inspired operators such as mutation, crossover and selection, as demonstrated in previous works on evolving rigid robots [31, 39]. We implement a simple GA using elitism selection and a simple mutation strategy to evolve the population of robot designs. Specifically, in each generation, our elitism selection works by keeping the top $x \\%$ of the robots from the current population as survivors and discarding the rest, where $x$ decreases gradually from 60 to 0 over generations. Next, we iteratively sample and mutate one of those survivors with $1 \\dot { 0 } \\%$ probability of changing each voxel of the robot to create more offsprings. Note that by mutating a voxel type from/to empty voxel, we are able to change the topology of the robot. The crossover operator is not implemented in our genetic algorithm. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            92,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Bayesian optimization (BO) BO [20, 25] is a commonly used global optimization method for black-box functions by learning and utilizing a surrogate model, which is usually employed to optimize expensive-to-evaluate functions, including evolving rigid robots in previous works [29, 21]. Specifically, we choose a batch BO algorithm as described in Kandasamy et al. [18] and implemented in the GPyOpt package [4] that supports categorical input data. We use Gaussian processes as the surrogate model, batch Thompson sampling for extracting the acquisition function, and L-BFGS algorithm to optimize the acquisition function. To ensure a fair comparison with other populationbased evolutionary baseline algorithms, the batch size of this algorithm is set equal to the population size of other algorithms. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            263
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CPPN-NEAT CPPN-NEAT is the predominant method for evolving soft robot design in previous literature [6, 7, 8]. In this method, the robot design is parameterized by a Compositional Pattern Producing Network (CPPN) [33]. The input to a CPPN is the spatial coordinate of a robot voxel and the output is the type of that voxel. Therefore, by querying the CPPN at all the spatial locations of a robot, we can obtain the type for each voxel to construct a robot. At the same time the NeuroEvolution of Augmenting Topologies (NEAT) algorithm [34] is used to evolve the structure of CPPNs by working as a genetic algorithm with specific mutation, crossover, and selection operators defined on network structures. Our implementation of CPPN-NEAT is based on the PyTorch-NEAT library [28] and the neat-python library [22]. ",
+        "bbox": [
+            173,
+            270,
+            825,
+            395
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 Control optimization ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            411,
+            357,
+            426
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce the specific control optimization algorithm (OPTIMIZECONTROL in Algorithm 1) that we use in the robot evolution algorithms. In previous works on evolving soft robots, the controller is either encoded as a fixed periodic sequence of actuation [7] or is parameterized as a CPPN that outputs the frequency and phase offset of the periodic actuation for each voxel [8]. However, the periodic pattern of the control prevents robots from learning complex non-periodic tasks such as walking on uneven or varying terrains. Therefore, we use reinforcement learning (RL) [35] to train the controller, making it possible for the soft robots to perform arbitrarily complex tasks in our benchmark. Specifically, we apply a state-of-the-art RL algorithm named Proximal Policy Optimization (PPO) [30] for control optimization of robots, with code implementation given by [19]. ",
+        "bbox": [
+            174,
+            436,
+            825,
+            561
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 Experiments and results ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            408,
+            598
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we present the evaluation results of baseline robot co-design algorithms on 10 selected benchmark tasks described in Section 3.5. The complete evaluation results on all our benchmark tasks can be found in Appendix E. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We develop three baseline algorithms for robot evolution by combing the three design optimization methods in Section 4.1 and PPO for control optimization in Section 4.2. Since the control optimization method is the same for all baseline algorithms, we simply use GA, BO, CPPN-NEAT to denote these three baseline algorithms with different design optimization methods. The evaluations of our baseline algorithms are performed on machines with Intel Xeon CPU $\\textcircled { \\omega } 2 . 8 0 \\mathrm { G H z } ^ { \\ast } 8 0$ processors on Google Cloud Platform; GPU is not required. Evaluating one algorithm on a single task usually takes several hours to twenty hours, depending on the number of evaluations, size of population, etc. See Appendix D for more details on hyperparameters of all the experiments. ",
+        "bbox": [
+            174,
+            661,
+            825,
+            772
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.1 Comparisons among baseline algorithms ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            496,
+            803
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We plot the reward curves of the three baseline algorithms on 10 selected benchmark tasks in Figure 3. There is no single optimal algorithm that performs the best on all tasks, but overall, GA outperforms the other two baseline algorithms. This is surprising because our genetic algorithm is implemented with simple and intuitive operators for mutation and selection without sophisticated mechanisms. Therefore, we believe that with more carefully designed operators, GA has the potential to evolve much more intelligent robots. CPPN-NEAT generally performs well on locomotion tasks, as tested by previous works, but performs poorly on more complex manipulation tasks. This is possibly because ",
+        "bbox": [
+            174,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "NEAT favors CPPNs with simpler structures, which encourages CPPNs to generate robots with more regular patterns. However, to succeed in complex manipulation tasks, some agile substructures of the robot must evolve, which might only exist in robots with irregular patterns. Finally, it is not surprising that BO performs poorly on most of the tasks because the high-dimensional categorical input parameter space and the noisy evaluation done by RL together pose a challenge to fitting an accurate surrogate model in BO. ",
+        "bbox": [
+            173,
+            90,
+            825,
+            174
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/28e51489c7a7245067ab9847f4db9c6e44c41dc3361b5bced78ec9e49378767c.jpg",
+        "image_caption": [
+            "Figure 3: Performance comparison among baseline algorithms. We plot the best performance of robots that each algorithm has evolved w.r.t. the number of evaluations on each task. All the curves are averaged over 6 different random seeds, and the variance is shown as a shaded region. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            193,
+            813,
+            479
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/d519dc86079772f8349aceead1bdea35217b757992471ed111590a2dd19d2cf5.jpg",
+        "image_caption": [
+            "Figure 4: Evolution of robot designs. For each of the three selected tasks, we visualize the population in three different generations. Each column corresponds to one generation for which we show the four top performing robots along with their average reward. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            553,
+            808,
+            747
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.2 Evolution analysis ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            809,
+            339,
+            824
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In Figure 4 we visualize the top four robots in three different generations on training the genetic algorithm for the Carrier, Lifter, and Bridge Walker task. We also show the average reward these designs achieve. ",
+        "bbox": [
+            174,
+            835,
+            825,
+            876
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the carrier task, the robot must catch an object that falls from above and then carry that object as far as possible. Therefore, a successful design for this task achieves two main goals 1) allowing the robot to catch and hold the object securely 2) allowing the robot to move fast. We observe that robots with a block-holding mechanism and with legs are selected for in the top survivors of generation 1 (randomly initialized). As evolution progresses, these structures become increasingly optimized. Specifically, in later generations, the robots’ structures allow them to walk faster while still preventing the block from falling. ",
+        "bbox": [
+            174,
+            883,
+            821,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8ffffcf3f893ce0f4598ad550be5790e071afbff144f94f4526036d0285a0e16.jpg",
+        "image_caption": [
+            "Figure 5: Comparison between algorithm-optimized robots and hand designed robots on three tasks. In each task, we visualize one robot optimized by the algorithm and several hand-designed robots. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            66,
+            825,
+            323
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            404,
+            825,
+            473
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "A similar comparison pattern can be seen in the Lifter task, where the algorithm learns a parallel gripper-like shape underneath the robot in order to manipulate an object. Unlike in the carrier task, the design structures that the algorithm generates are not prominently found in the initial generation. Finally, these patterns are echoed in the Bridge Walker task. Here the robot learns to evolve a large front foot to maximize its surface area and friction force to best walk across the soft rope bridge. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            549
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.3 Comparison against hand-designed robots ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            573,
+            506,
+            587
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We compare the performances of robots optimized by algorithm and the hand designed robots on several tasks to show the necessity of a co-design algorithm (Figure 5). The structure of the hand designed robots are bio-inspired and manually constructed according to our best intuition, and their control are optimized by PPO. ",
+        "bbox": [
+            174,
+            601,
+            825,
+            656
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For every task, the hand designed robots are outperformed by at least one algorithm (usually more). For instance, for the Climber task we tested numerous natural robot designs. However, none of them successfully climbed very far. The issue with our designs is that we could not find the right trade off between getting traction on the wall, and accelerating upwards. The genetic algorithm, however, is able to find this balance. It develops leg-like structures that help the robot make forward progress, as well as a long flat back that maximizes contact/frictional forces with the wall. Additionally, the genetic algorithm selects for having a hole in the center of its body, which helps it achieve a certain optimized walking motion. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            773
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For other tasks, the performance between the hand designed robots and the robots produced by the algorithms is quite comparable. This is the case with the Carrier robots, as a very natural hand-designed Carrier robot performs almost as well as the best optimized robots produced by the design-optimization algorithms. ",
+        "bbox": [
+            174,
+            780,
+            825,
+            835
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the final case, there are tasks where neither a hand designed nor robot produced by the algorithm could achieve satisfying performance. One such environment is the Beam Slider environment. For this task, many of the hand design robots fail to even achieve the first part of the goal and position themselves underneath the beam. While there is one robot produced by the genetic algorithm that does slide the beam across several pegs, from visual observation we believe it comes nowhere close to exhibiting the optimal behavior in this environment. This suggests that further work is needed in designing co-optimization algorithms that can complete these hard tasks. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            92,
+            823,
+            119
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusion and future work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            140,
+            439,
+            157
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper we proposed Evolution Gym, the first large-scale benchmark for evolving the structure and control of soft robots. Through the wide spectrum of tasks in Evolution Gym, we systematically studied the performance of current state-of-the-art co-design algorithms. As a result, we observed how intelligent robots could be evolved autonomously from scratch yet still be capable of accomplishing some surprisingly complex tasks. We also discovered the limitations of existing techniques for evolving more intelligent embodied systems. ",
+        "bbox": [
+            174,
+            171,
+            825,
+            255
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are several potential directions to be explored in the future. First, with the help of our proposed benchmark, it is desirable to develop more advanced co-design algorithms to solve the difficult tasks which existing methods cannot address. Our currently implemented baseline algorithms share a bi-level optimization routine where the design optimization is in the outer loop while the control optimization is in the inner loop. However, Evolution Gym is agnostic to the specific training procedure used. As a result, some ideas for future work using our framework could include concurrently co-optimizing the design and control, neuroevolution algorithms, morphogenetic development, gradient-based methods for design optimization, or algorithms with decentralized controllers. ",
+        "bbox": [
+            174,
+            262,
+            825,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Second, a robot will be considered more successful if it can perform multiple tasks. Our benchmark suite naturally provides a comprehensive set of tasks and can potentially promote more exciting research work about multi-task or multi-objective robot co-design algorithms. ",
+        "bbox": [
+            176,
+            378,
+            820,
+            421
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Another consideration is the specific morphological encodings used by the codesign algorithms as more intelligent encodings could lead to better performance. For instance, [38] analyzes the strengths and weaknesses of different morphological encodings. Our baseline algorithms use a direct encoding and CPPN but exploring other encoding representations remains interesting future work. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Finally, since tasks in Evolution Gym are currently limited to either locomotion or manipulation, we plan to further extend Evolution Gym to additional task categories such as flying or swimming by incorporating new simulation capabilities. ",
+        "bbox": [
+            176,
+            489,
+            821,
+            530
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Overall, we believe our carefully-designed benchmarking tool fills an important missing piece in research in soft robotics and robotic evolution algorithms. Armed with the flexible and expressive framework Evolution Gym provides, we are optimistic that future researchers will use Evolution Gym as a standard test bed to improve co-design methods and evolve more intelligent robots. ",
+        "bbox": [
+            174,
+            537,
+            825,
+            593
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Societal Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            613,
+            305,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We regard this work as a very preliminary piece of research in the field of soft robot co-design, and therefore think that we are still far away from causing harm to society. However, we can definitely foresee some problems if this technology were to be applied in the real world on a large scale. For instance, this work may inspire the automatic design of real biological creatures in which serious ethical issues exist. Additionally, since the users have full control over the reward design when customizing the benchmark environments, they could specify pernicious goals and encourage the co-design algorithm to produce more biased results. ",
+        "bbox": [
+            174,
+            645,
+            825,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            762,
+            553,
+            781
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Tao Du and the anonymous reviewers for their helpful comments in revising the paper. This work is supported by the Defense Advanced Research Projects Agency (FA8750-20-C-0075). ",
+        "bbox": [
+            174,
+            795,
+            825,
+            824
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            844,
+            266,
+            861
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[1] Ilge Akkaya, Marcin Andrychowicz, Maciek Chociej, Mateusz Litwin, Bob McGrew, Arthur Petron, Alex Paino, Matthias Plappert, Glenn Powell, Raphael Ribas, et al. Solving rubik’s cube with a robot hand. arXiv preprint arXiv:1910.07113, 2019. ",
+        "bbox": [
+            183,
+            869,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "[2] OpenAI: Marcin Andrychowicz, Bowen Baker, Maciek Chociej, Rafal Jozefowicz, Bob McGrew, Jakub Pachocki, Arthur Petron, Matthias Plappert, Glenn Powell, Alex Ray, et al. Learning dexterous in-hand manipulation. The International Journal of Robotics Research, 39(1):3–20, 2020.   \n[3] Jacob Austin, Rafael Corrales-Fatou, Sofia Wyetzner, and Hod Lipson. Titan: A parallel asynchronous library for multi-agent and soft-body robotics using nvidia cuda. In 2020 IEEE International Conference on Robotics and Automation (ICRA), pages 7754–7760, 2020.   \n[4] The GPyOpt authors. GPyOpt: A bayesian optimization framework in python. http:// github.com/SheffieldML/GPyOpt, 2016.   \n[5] Greg Brockman, Vicki Cheung, Ludwig Pettersson, Jonas Schneider, John Schulman, Jie Tang, and Wojciech Zaremba. Openai gym, 2016.   \n[6] Nicholas Cheney, Jeff Clune, and Hod Lipson. Evolved electrophysiological soft robots. In Artificial Life Conference Proceedings 14, pages 222–229. MIT Press, 2014.   \n[7] Nick Cheney, Robert MacCurdy, Jeff Clune, and Hod Lipson. Unshackling evolution: Evolving soft robots with multiple materials and a powerful generative encoding. SIGEVOlution, 7(1):11–23, August 2014.   \n[8] Francesco Corucci, Nick Cheney, Francesco Giorgio-Serchi, Josh Bongard, and Cecilia Laschi. Evolving soft locomotion in aquatic and terrestrial environments: effects of material properties and environmental transitions, 2017.   \n[9] Francesco Corucci, Nick Cheney, Francesco Giorgio-Serchi, Josh Bongard, and Cecilia Laschi. Evolving soft locomotion in aquatic and terrestrial environments: effects of material properties and environmental transitions. Soft robotics, 5(4):475–495, 2018.   \n[10] Francesco Corucci, Nick Cheney, Hod Lipson, Cecilia Laschi, and Josh Bongard. Evolving swimming soft-bodied creatures. In ALIFE XV, The Fifteenth International Conference on the Synthesis and Simulation of Living Systems, Late Breaking Proceedings, volume 6, 2016.   \n[11] Yan Duan, Xi Chen, Rein Houthooft, John Schulman, and Pieter Abbeel. Benchmarking deep reinforcement learning for continuous control. In International conference on machine learning, pages 1329–1338. PMLR, 2016.   \n[12] Christer Ericson. Real-time collision detection. CRC Press, 2004.   \n[13] David Ha. Reinforcement learning for improving agent design. Artificial life, 25(4):352–365, 2019.   \n[14] Donald J Hejna III, Pieter Abbeel, and Lerrel Pinto. Task-agnostic morphology evolution. arXiv preprint arXiv:2102.13100, 2021.   \n[15] Jonathan Hiller and Hod Lipson. Dynamic simulation of soft multimaterial 3d-printed objects. Soft robotics, 1(1):88–101, 2014.   \n[16] Zhiao Huang, Yuanming Hu, Tao Du, Siyuan Zhou, Hao Su, Joshua B. Tenenbaum, and Chuang Gan. Plasticinelab: A soft-body manipulation benchmark with differentiable physics, 2021.   \n[17] Jemin Hwangbo, Joonho Lee, Alexey Dosovitskiy, Dario Bellicoso, Vassilios Tsounis, Vladlen Koltun, and Marco Hutter. Learning agile and dynamic motor skills for legged robots. Science Robotics, 4(26), 2019.   \n[18] Kirthevasan Kandasamy, Akshay Krishnamurthy, Jeff Schneider, and Barnabás Póczos. Parallelised bayesian optimisation via thompson sampling. In International Conference on Artificial Intelligence and Statistics, pages 133–142. PMLR, 2018.   \n[19] Ilya Kostrikov. Pytorch implementations of reinforcement learning algorithms. https:// github.com/ikostrikov/pytorch-a2c-ppo-acktr-gail, 2018.   \n[20] Harold J Kushner. A new method of locating the maximum point of an arbitrary multipeak curve in the presence of noise. 1964.   \n[21] Thomas Liao, Grant Wang, Brian Yang, Rene Lee, Kristofer Pister, Sergey Levine, and Roberto Calandra. Data-efficient learning of morphology and controller for a microrobot. In 2019 International Conference on Robotics and Automation (ICRA), pages 2488–2494. IEEE, 2019.   \n[22] Alan McIntyre, Matt Kallada, Cesar G. Miguel, and Carolina Feher da Silva. neat-python. https://github.com/CodeReclaimers/neat-python.   \n[23] Eric Medvet, Alberto Bartoli, Andrea De Lorenzo, and Stefano Seriani. 2d-vsr-sim: A simulation tool for the optimization of 2-d voxel-based soft robots. SoftwareX, 12:100573, 2020.   \n[24] Zbigniew Michalewicz. Genetic algorithms $^ +$ data structures $=$ evolution programs. Springer Science & Business Media, 2013.   \n[25] J. Mockus. On bayesian methods for seeking the extremum. In G. I. Marchuk, editor, ˇ Optimization Techniques IFIP Technical Conference Novosibirsk, July 1–7, 1974, pages 400–404, Berlin, Heidelberg, 1975. Springer Berlin Heidelberg.   \n[26] Andrew Nealen, Matthias Müller, Richard Keiser, Eddy Boxerman, and Mark Carlson. Physically based deformable models in computer graphics. In Computer graphics forum, volume 25, pages 809–836. Wiley Online Library, 2006.   \n[27] Deepak Pathak, Chris Lu, Trevor Darrell, Phillip Isola, and Alexei A Efros. Learning to control self-assembling morphologies: a study of generalization via modularity. arXiv preprint arXiv:1902.05546, 2019.   \n[28] Uber Research. pytorch-neat. https://github.com/uber-research/PyTorch-NEAT.   \n[29] Charles Schaff, David Yunis, Ayan Chakrabarti, and Matthew R Walter. Jointly learning to construct and control agents using deep reinforcement learning. In 2019 International Conference on Robotics and Automation (ICRA), pages 9798–9805. IEEE, 2019.   \n[30] John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms, 2017.   \n[31] Karl Sims. Evolving virtual creatures. In Proceedings of the 21st annual conference on Computer graphics and interactive techniques, pages 15–22, 1994.   \n[32] Andrew Spielberg, Allan Zhao, Yuanming Hu, Tao Du, Wojciech Matusik, and Daniela Rus. Learning-in-the-loop optimization: End-to-end control and co-design of soft robots through learned deep latent representations. In H. Wallach, H. Larochelle, A. Beygelzimer, F. d'Alché- Buc, E. Fox, and R. Garnett, editors, Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.   \n[33] Kenneth O Stanley. Compositional pattern producing networks: A novel abstraction of development. Genetic programming and evolvable machines, 8(2):131–162, 2007.   \n[34] Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary computation, 10(2):99–127, 2002.   \n[35] Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.   \n[36] Yuval Tassa, Yotam Doron, Alistair Muldal, Tom Erez, Yazhe Li, Diego de Las Casas, David Budden, Abbas Abdolmaleki, Josh Merel, Andrew Lefrancq, Timothy Lillicrap, and Martin Riedmiller. Deepmind control suite, 2018.   \n[37] Merel Van Diepen and Kristina Shea. A spatial grammar method for the computational design synthesis of virtual soft locomotion robots. Journal of Mechanical Design, 141(10), 2019.   \n[38] Frank Veenstra and Kyrre Glette. How different encodings affect performance and diversification when evolving the morphology and control of 2d virtual creatures. In Artificial Life Conference Proceedings, pages 592–601. MIT Press, 2020.   \n[39] Tingwu Wang, Yuhao Zhou, Sanja Fidler, and Jimmy Ba. Neural graph evolution: Towards efficient automatic robot design, 2019.   \n[40] Fei Xia, Amir R Zamir, Zhiyang He, Alexander Sax, Jitendra Malik, and Silvio Savarese. Gibson env: Real-world perception for embodied agents. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pages 9068–9079, 2018.   \n[41] Allan Zhao, Jie Xu, Mina Konakovic-Lukovi ´ c, Josephine Hughes, Andrew Spielberg, Daniela ´ Rus, and Wojciech Matusik. Robogrammar: Graph grammar for terrain-optimized robot design. ACM Trans. Graph., 39(6), November 2020. ",
+        "bbox": [
+            171,
+            58,
+            828,
+            919
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            37,
+            828,
+            917
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            90,
+            826,
+            184
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            89,
+            254,
+            106
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            116,
+            339,
+            130
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes] See Section 6.   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes] See Section 6.   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            135,
+            825,
+            239
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            243,
+            493,
+            258
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [N/A] (b) Did you include complete proofs of all theoretical results? [N/A] ",
+        "bbox": [
+            238,
+            262,
+            738,
+            294
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            212,
+            299,
+            393,
+            313
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] The URL is presented in the abstract.   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] See Appendix D.   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes] We ran experiments with multiple random seeds and reported error bars. See Section 5.   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Section 5. ",
+        "bbox": [
+            238,
+            316,
+            825,
+            463
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            218,
+            467,
+            823,
+            482
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] The existing code implementation for our baseline algorithms are cited in Section 4.   \n(b) Did you mention the license of the assets? [Yes] This benchmark platform will be released under the MIT license. See Section 1.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes] The URL is presented in the abstract.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            486,
+            825,
+            635
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            638,
+            705,
+            654
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            657,
+            825,
+            747
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJgUfTEYvH/rJgUfTEYvH.md

@@ -0,0 +1,374 @@
+# VIDEOFLOW: A CONDITIONAL FLOW-BASED MODEL FOR STOCHASTIC VIDEO GENERATION
+
+Manoj Kumar∗, Mohammad Babaeizadeh, Dumitru Erhan, Chelsea Finn, Sergey Levine, Laurent Dinh, Durk Kingma
+
+Google Research, Brain Team {mechcoder,mbz,dumitru,chelseaf,slevine,laurentdinh,durk}@google.com
+
+# ABSTRACT
+
+Generative models that can model and predict sequences of future events can, in principle, learn to capture complex real-world phenomena, such as physical interactions. However, a central challenge in video prediction is that the future is highly uncertain: a sequence of past observations of events can imply many possible futures. Although a number of recent works have studied probabilistic models that can represent uncertain futures, such models are either extremely expensive computationally as in the case of pixel-level autoregressive models, or do not directly optimize the likelihood of the data. To our knowledge, our work is the first to propose multi-frame video prediction with normalizing flows, which allows for direct optimization of the data likelihood, and produces high-quality stochastic predictions. We describe an approach for modeling the latent space dynamics, and demonstrate that flow-based generative models offer a viable and competitive approach to generative modeling of video.
+
+# 1 INTRODUCTION
+
+Exponential progress in the capabilities of computational hardware, paired with a relentless effort towards greater insights and better methods, has pushed the field of machine learning from relative obscurity into the mainstream. Progress in the field has translated to improvements in various capabilities, such as classification of images (Krizhevsky et al., 2012), machine translation (Vaswani et al., 2017) and super-human game-playing agents (Mnih et al., 2013; Silver et al., 2017), among others. However, the application of machine learning technology has been largely constrained to situations where large amounts of supervision is available, such as in image classification or machine translation, or where highly accurate simulations of the environment are available to the learning agent, such as in game-playing agents. An appealing alternative to supervised learning is to utilize large unlabeled datasets, combined with predictive generative models. In order for a complex generative model to be able to effectively predict future events, it must build up an internal representation of the world. For example, a predictive generative model that can predict future frames in a video would need to model complex real-world phenomena, such as physical interactions. This provides an appealing mechanism for building models that have a rich understanding of the physical world, without any labeled examples. Videos of real-world interactions are plentiful and readily available, and a large generative model can be trained on large unlabeled datasets containing many video sequences, thereby learning about a wide range of real-world phenoma. Such a model could be useful for learning representations for further downstream tasks (Mathieu et al., 2016), or could even be used directly in applications where predicting the future enables effective decision making and control, such as robotics (Finn et al., 2016). A central challenge in video prediction is that the future is highly uncertain: a short sequence of observations of the present can imply many possible futures. Although a number of recent works have studied probabilistic models that can represent uncertain futures, such models are either extremely expensive computationally (as in the case of pixel-level autoregressive models), or do not directly optimize the likelihood of the data.
+
+In this paper, we study the problem of stochastic prediction, focusing specifically on the case of conditional video prediction: synthesizing raw RGB video frames conditioned on a short context of past observations (Ranzato et al., 2014; Srivastava et al., 2015; Vondrick et al., 2015; Xingjian et al., 2015; Boots et al., 2014). Specifically, we propose a new class of video prediction models that can provide exact likelihoods, generate diverse stochastic futures, and accurately synthesize realistic and high-quality video frames. The main idea behind our approach is to extend flow-based generative models (Dinh et al., 2014; 2016) into the setting of conditional video prediction. To our knowledge, flow-based models have been applied only to generation of non-temporal data, such as images (Kingma & Dhariwal, 2018), and to audio sequences (Prenger et al., 2018). Conditional generation of videos presents its own unique challenges: the high dimensionality of video sequences makes them difficult to model as individual datapoints. Instead, we learn a latent dynamical system model that predicts future values of the flow model’s latent state. This induces Markovian dynamics on the latent state of the system, replacing the standard unconditional prior distribution. We further describe a practically applicable architecture for flow-based video prediction models, inspired by the Glow model for image generation (Kingma & Dhariwal, 2018), which we call VideoFlow.
+
+Our empirical results show that VideoFlow achieves results that are competitive with the state-ofthe-art in stochastic video prediction on the action-free BAIR dataset, with quantitative results that rival the best VAE-based models. VideoFlow also produces excellent qualitative results, and avoids many of the common artifacts of models that use pixel-level mean-squared-error for training (e.g., blurry predictions), without the challenges associated with training adversarial models. Compared to models based on pixel-level autoregressive prediction, VideoFlow achieves substantially faster test-time image synthesis 1, making it much more practical for applications that require real-time prediction, such as robotic control (Finn & Levine, 2017). Finally, since VideoFlow directly optimizes the likelihood of training videos, without relying on a variational lower bound, we can evaluate its performance directly in terms of likelihood values.
+
+# 2 RELATED WORK
+
+Early work on prediction of future video frames focused on deterministic predictive models (Ranzato et al., 2014; Srivastava et al., 2015; Vondrick et al., 2015; Xingjian et al., 2015; Boots et al., 2014). Much of this research on deterministic models focused on architectural changes, such as predicting high-level structure (Villegas et al., 2017b), energy-based models (Xie et al., 2017), generative cooperative nets (Xie et al., 2020), ABPTT (Xie et al., 2019), incorporating pixel transformations (Finn et al., 2016; De Brabandere et al., 2016; Liu et al., 2017) and predictive coding architectures (Lotter et al., 2017), as well as different generation objectives (Mathieu et al., 2016; Vondrick & Torralba, 2017; Walker et al., 2015) and disentangling representations (Villegas et al., 2017a; Denton & Birodkar, 2017). With models that can successfully model many deterministic environments, the next key challenge is to address stochastic environments by building models that can effectively reason over uncertain futures. Real-world videos are always somewhat stochastic, either due to events that are inherently random, or events that are caused by unobserved or partially observable factors, such as off-screen events, humans and animals with unknown intentions, and objects with unknown physical properties. In such cases, since deterministic models can only generate one future, these models either disregard potential futures or produce blurry predictions that are the superposition or averages of possible futures.
+
+A variety of methods have sought to overcome this challenge by incorporating stochasticity, via three types of approaches: models based on variational auto-encoders (VAEs) (Kingma & Welling, 2013; Rezende et al., 2014), generative adversarial networks (Goodfellow et al., 2014), and autoregressive models (Hochreiter & Schmidhuber, 1997; Graves, 2013; van den Oord et al., 2016b;c; Van Den Oord et al., 2016).
+
+Among these models, techniques based on variational autoencoders which optimize an evidence lower bound on the log-likelihood have been explored most widely (Babaeizadeh et al., 2017; Denton & Fergus, 2018; Lee et al., 2018; Xue et al., 2016; Li et al., 2018). To our knowledge, the only prior class of video prediction models that directly maximize the log-likelihood of the data are autoregressive models (Hochreiter & Schmidhuber, 1997; Graves, 2013; van den Oord et al., 2016b;c; Van Den Oord et al., 2016), that generate the video one pixel at a time (Kalchbrenner et al., 2017). However, synthesis with such models is typically inherently sequential, making synthesis substantially inefficient on modern parallel hardware. Prior work has aimed to speed up training and synthesis with such auto-regressive models (Reed et al., 2017; Ramachandran et al., 2017). However, (Babaeizadeh et al., 2017) show that the predictions from these models are sharp but noisy and that the proposed VAE model produces substantially better predictions, especially for longer horizons. In contrast to autoregressive models, we find that our proposed method exhibits faster sampling, while still directly optimizing the log-likelihood and producing high-quality long-term predictions.
+
+![](images/0027199eb377c5633427a680c43a111c27c2795241099f59d443abe1ba5557b4.jpg)  
+Figure 1: Left: Multi-scale prior The flow model uses a multi-scale architecture using several levels of stochastic variables. Right: Autoregressive latent-dynamic prior The input at each timestep $\mathbf { x } _ { t }$ is encoded into multiple levels of stochastic variables $( \mathbf { z } _ { t } ^ { ( 1 ) } , \ldots , \mathbf { z } _ { t } ^ { ( L ) } )$ z(L)t ). We model those levels through a sequential process $\begin{array} { r } { \prod _ { t } \prod _ { l } p ( \mathbf { \hat { z } } _ { t } ^ { ( l ) } \mid \mathbf { z } _ { < t } ^ { ( l ) } , \mathbf { z } _ { t } ^ { ( > l ) } ) } \end{array}$ .
+
+# 3 PRELIMINARIES: FLOW-BASED GENERATIVE MODELS
+
+Flow-based generative models (Dinh et al., 2014; 2016) have a unique set of advantages: exact latentvariable inference, exact log-likelihood evaluation, and parallel sampling. In flow-based generative models (Dinh et al., 2014; 2016), we infer the latent variable $\mathbf { z }$ corresponding to a datapoint $\mathbf { x }$ , by transforming $\mathbf { x }$ through a composition of invertible functions $\mathbf { f } = \mathbf { f } _ { 1 } \circ \mathbf { f } _ { 2 } \circ \cdots \circ \mathbf { f } _ { K }$ . We assume a tractable prior $p _ { \pmb { \theta } } ( \mathbf { z } )$ over latent variable $\mathbf { z }$ , for eg. a Logistic or a Gaussian distribution. By constraining the transformations to be invertible, we can compute the log-likelihood of $\mathbf { x }$ exactly using the change of variables rule. Formally,
+
+$$
+\log p _ { \pmb \theta } ( \mathbf x ) = \log p _ { \pmb \theta } ( \mathbf z ) + \sum _ { i = 1 } ^ { K } \log | \operatorname* { d e t } ( d \mathbf h _ { i } / d \mathbf h _ { i - 1 } ) |
+$$
+
+where $\mathbf { h } _ { 0 } = \mathbf { x }$ , $\mathbf { h } _ { i } = \mathbf { f } _ { i } ( \mathbf { h } _ { i - 1 } )$ , $\mathbf { h } _ { K } = \mathbf { z }$ and $| \operatorname* { d e t } ( d \mathbf { h } _ { i } / d \mathbf { h } _ { i - 1 } |$ is the Jacobian determinant when $\mathbf { h } _ { i - 1 }$ is transformed to $\mathbf { h } _ { i }$ by $\mathbf { f } _ { i }$ . We learn the parameters of $\mathbf { f } _ { 1 } \ldots . \mathbf { f } _ { K }$ by maximizing the log-likelihood, i.e Equation (1), over a training set. Given $\mathbf { g } = \mathbf { f } ^ { - 1 }$ , we can now generate a sample $\hat { \bf x }$ from the data distribution, by sampling $\mathbf { z } \sim p _ { \pmb { \theta } } ( \mathbf { z } )$ and computing $\hat { \mathbf { x } } = \mathbf { g } ( \mathbf { z } )$ .
+
+# 4 PROPOSED ARCHITECTURE
+
+We propose a generative flow for video, using the standard multi-scale flow architecture in (Dinh et al., 2016; Kingma & Dhariwal, 2018) as a building block. In our model, we break up the latent space $\mathbf { z }$ into separate latent variables per timestep: $\mathbf { z } = \{ \mathbf { z } _ { t } \} _ { t = 1 } ^ { T }$ . The latent variable $\mathbf { z } _ { t }$ at timestep $t$ is an invertible transformation of a corresponding frame of video: $\mathbf { x } _ { t } = \mathbf { g } _ { \theta } ( \mathbf { z } _ { t } )$ . Furthermore, like in (Dinh et al., 2016; Kingma & Dhariwal, 2018), we use a multi-scale architecture for ${ \bf g } _ { \pmb { \theta } } ( { \bf z } _ { t } )$ (Fig. 1): the latent variable $\mathbf { z } _ { t }$ is composed of a stack of multiple levels: where each level $l$ encodes information about frame $\mathbf { x } _ { t }$ at a particular scale: $\mathbf { z } _ { t } = \{ \mathbf { z } _ { t } ^ { ( l ) } \} _ { l = 1 } ^ { \bar { L } }$ , one component $\mathbf { z } _ { t } ^ { ( l ) }$ per level.
+
+We first briefly describe the invertible transformations used in the multi-scale architecture to infer $\{ \mathbf { z } _ { t } ^ { ( l ) } \} _ { l = 1 } ^ { L } = \mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } _ { t } )$ and refer to (Dinh et al., 2016; Kingma & Dhariwal, 2018) for more details. For convenience, we omit the subscript $t$ in this subsection. We choose invertible transformations whose Jacobian determinant in Equation 1 is simple to compute, that is a triangular matrix, diagonal matrix or a permutation matrix as explored in prior work (Rezende & Mohamed, 2015; Deco & Brauer, 1995). For permutation matrices, the Jacobian determinant is one and for triangular and diagonal Jacobian matrices, the determinant is simply the product of diagonal terms.
+
+• Actnorm: We apply a learnable per-channel scale and shift with data-dependent initialization.   
+• Coupling: We split the input $y$ equally across channels to obtain $y _ { 1 }$ and $y _ { 2 }$ . We compute $z _ { 2 } = f ( y _ { 1 } ) * y _ { 2 } + g ( y _ { 1 } )$ where $f$ and $g$ are deep networks. We concat $y _ { 1 }$ and $z _ { 2 }$ across channels.   
+• SoftPermute: We apply a 1x1 convolution that preserves the number of channels.   
+• Squeeze: We reshape the input from $H \times W \times C$ to $H / 2 \times W / 2 \times 4 C$ which allows the flow to operate on a larger receptive field.
+
+We infer the latent variable $z ^ { ( l ) }$ at level $l$ using:
+
+$$
+\begin{array} { r l } & { \operatorname { F l o w } ( y ) = \operatorname { C o u p l i n g } ( \operatorname { S o f t P e r m u t e } ( \operatorname { A c t n o r m } ( y ) ) ) ) \times N } \\ & { \operatorname { F l o w } _ { \mathrm { 1 } } ( y ) = \operatorname { S p l i t } ( \operatorname { F l o w } ( \operatorname { S q u e e z e } ( y ) ) ) } \\ & { ( \mathbf { h } ^ { ( > l ) } , \mathbf { z } ^ { l } )  \operatorname { F l o w } _ { \mathrm { 1 } } ( \mathbf { h } ^ { ( > l - 1 ) } ) } \end{array}
+$$
+
+where $N$ is the number of steps of flow. In Equation (3), via Split, we split the output of Flow equally across channels into $\mathbf { h } ^ { ( > l ) }$ , the input to $\mathrm { F l o w } _ { ( \mathrm { l + 1 } ) } ( . )$ and $z ^ { ( l ) }$ , the latent variable at level $l$ . We, thus enable the flows at higher levels to operate on a lower number of dimensions and larger scales. When $l = 1$ , $\mathbf { h } ^ { ( > l - 1 ) }$ is just the input frame $x$ and for $l = L$ we omit the Split operation. Finally, our multi-scale architecture $\mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } _ { t } )$ is a composition of the flows at multiple levels from $l = 1 \ldots L$ from which we obtain our latent variables i.e $\{ \mathbf { z } _ { t } ^ { ( l ) } \} _ { l = 1 } ^ { L }$ .
+
+# 4.2 AUTOREGRESSIVE LATENT DYNAMICS MODEL
+
+We use the multi-scale architecture described above to infer the set of corresponding latent variables for each individual frame of the video: $\{ \mathbf { z } _ { t } ^ { ( l ) } \} _ { l = 1 } ^ { L } = \mathbf { f } _ { \pmb { \theta } } ( \mathbf { x } _ { t } )$ ; see Figure 1 for an illustration. As in Equation (1), we need to choose a form of latent prior $p _ { \pmb { \theta } } ( \mathbf { z } )$ . We use the following autoregressive factorization for the latent prior:
+
+$$
+p _ { \pmb { \theta } } ( \mathbf { z } ) = \prod _ { t = 1 } ^ { T } p _ { \pmb { \theta } } ( \mathbf { z } _ { t } | \mathbf { z } _ { < t } )
+$$
+
+where $\mathbf { z } _ { < t }$ denotes the latent variables of frames prior to the $t$ -th timestep: $\left\{ \mathbf { z } _ { 1 } , . . . , \mathbf { z } _ { t - 1 } \right\}$ . We specify the conditional prior $p _ { \pmb { \theta } } ( \mathbf { z } _ { t } | \mathbf { z } _ { < t } )$ as having the following factorization:
+
+$$
+p _ { \pmb { \theta } } \big ( \mathbf { z } _ { t } \big | \mathbf { z } _ { < t } \big ) = \prod _ { l = 1 } ^ { L } p _ { \pmb { \theta } } \big ( \mathbf { z } _ { t } ^ { ( l ) } \big | \mathbf { z } _ { < t } ^ { ( l ) } , \mathbf { z } _ { t } ^ { ( > l ) } \big )
+$$
+
+where z(l)<t is the set of latent variables at previous timesteps and at the same level $l$ , while $\mathbf { z } _ { t } ^ { ( > l ) }$ is the set of latent variables at the same timestep and at higher levels. See Figure 1 for a graphical illustration of the dependencies.
+
+We let each $p _ { \pmb { \theta } } ( \mathbf { z } _ { t } ^ { ( l ) } | \mathbf { z } _ { < t } ^ { ( l ) } , \mathbf { z } _ { t } ^ { ( > l ) } )$ be a conditionally factorized Gaussian density:
+
+$$
+\begin{array} { r l } & { p _ { \pmb { \theta } } ( \mathbf { z } _ { t } ^ { ( l ) } | \mathbf { z } _ { < t } ^ { ( l ) } , \mathbf { z } _ { t } ^ { ( > l ) } ) = \mathcal { N } ( \mathbf { z } _ { t } ^ { ( l ) } ; \pmb { \mu } , \sigma ) } \\ & { \quad \mathrm { w h e r e } \ ( \pmb { \mu } , \log \sigma ) = N N _ { \pmb { \theta } } ( \mathbf { z } _ { < t } ^ { ( l ) } , \mathbf { z } _ { t } ^ { ( > l ) } ) } \end{array}
+$$
+
+Table 1: We compare the realism of the generated trajectories using a real-vs-fake 2AFC Amazon Mechanical Turk with SAVP-VAE and SV2P.   
+
+<table><tr><td>Model</td><td>Fooling rate</td></tr><tr><td>SAVP-VAE</td><td>16.4 %</td></tr><tr><td>VideoFlow</td><td>31.8 %</td></tr><tr><td>SV2P</td><td>17.5 %</td></tr></table>
+
+![](images/d35db32dbe0a36e17916e99e637ed2949deae79ea445ab96809982139e8eebab.jpg)  
+Figure 2: We condition the VideoFlow model with the frame at $\mathrm { \Delta t } = 1$ and display generated trajectories at $\mathbf { t } = 2$ and $\mathrm { t } = 3$ for three different shapes.
+
+where $N N _ { \theta } ( . )$ is a deep 3-D residual network (He et al., 2015) augmented with dilations and gated activation units and modified to predict the mean and log-scale. We describe the architecture and our ablations of the architecture in Section D and E of the appendix.
+
+In summary, the log-likelhood objective of Equation (1) has two parts. The invertible multi-scale architecture contributes $\begin{array} { r l } { ~ } & { { } \sum _ { i = 1 } ^ { K } \log | \operatorname* { d e t } ( d \mathbf { h } _ { i } / d \mathbf { h } _ { i - 1 } ) | } \end{array}$ via the sum of the log Jacobian determinants of the invertible transformations mapping the video $\{ { \bf x } _ { t } \} _ { t = 1 } ^ { T }$ to $\{ \mathbf { z } _ { t } \} _ { t = 1 } ^ { T }$ ; the latent dynamics model contributes $\log p \pmb { \theta } ( \mathbf { z } )$ , i.e Equation (5). We jointly learn the parameters of the multi-scale architecture and latent dynamics model by maximizing this objective.
+
+Note that in our architecture we have chosen to let the prior $p _ { \pmb { \theta } } ( \mathbf { z } )$ , as described in eq. (5), model temporal dependencies in the data, while constraining the flow $\mathbf { g } _ { \theta }$ to act on separate frames of video. We have experimented with using 3-D convolutional flows, but found this to be computationally overly expensive compared to an autoregressive prior; in terms of both number of operations and number of parameters. Further, due to memory limits, we found it only feasible to perform SGD with a small number of sequential frames per gradient step. In case of 3-D convolutions, this would make the temporal dimension considerably smaller during training than during synthesis; this would change the model’s input distribution between training and synthesis, which often leads to various temporal artifacts. Using 2-D convolutions in our flow $\mathbf { f } _ { \theta }$ with autoregressive priors, allows us to synthesize arbitrarily long sequences without introducing such artifacts.
+
+# 5 EXPERIMENTS
+
+All our generated videos and qualitative results can be viewed at this website. In the generated videos, a border of blue represents the conditioning frame, while a border of red represents the generated frames.
+
+# 5.1 VIDEO MODELLING WITH THE STOCHASTIC MOVEMENT DATASET
+
+We use VideoFlow to model the Stochastic Movement Dataset used in (Babaeizadeh et al., 2017). The first frame of every video consists of a shape placed near the center of a 64x64x3 resolution gray background with its type, size and color randomly sampled. The shape then randomly moves in one of eight directions with constant speed. (Babaeizadeh et al., 2017) show that conditioned on the first frame, a deterministic model averages out all eight possible directions in pixel space. Since the shape moves with a uniform speed, we should be able to model the position of the shape at the $( t + 1 ) ^ { t h }$ step using only the position of the shape at the $t ^ { t h }$ step. Using this insight, we extract random temporal patches of 2 frames from each video of 3 frames. We then use VideoFlow to maximize the loglikelihood of the second frame given the first, i.e the model looks back at just one frame. We observe that the bits-per-pixel on the holdout set reduces to a very low 0.04 bits-per-pixel for this model. On generating videos conditioned on the first frame, we observe that the model consistently predicts the future trajectory of the shape to be one of the eight random directions. We compare our model with two state-of-the-art stochastic video generation models SV2P and SAVP-VAE (Babaeizadeh et al., 2017; Lee et al., 2018) using their Tensor2Tensor implementation (Vaswani et al., 2018). We assess the quality of the generated videos using a real vs fake Amazon Mechanical Turk test. In the test, we inform the rater that a "real" trajectory is one in which the shape is consistent in color and congruent throughout the video. We show that VideoFlow outperforms the baselines in terms of fooling rate in Table 1 consistently generating plausible "real" trajectories at a greater rate.
+
+Table 2: Left: We report the average bits-per-pixel across 10 target frames with 3 conditioning frames for the BAIR action-free dataset.   
+
+<table><tr><td>Model</td><td>Bits-per-pixel</td></tr><tr><td>VideoFlow</td><td>1.87</td></tr><tr><td>SAVP-VAE</td><td>≤6.73</td></tr><tr><td>SV2P</td><td>≤6.78</td></tr></table>
+
+![](images/4f86fdecfe5c88f19ab3804eaa6bdd874d0e3a55b517fd8a901450bd247a62a3.jpg)  
+Figure 3: We measure realism using a 2AFC test and diversity using mean pairwise cosine distance between generated samples in VGG perceptual space.
+
+# 5.2 VIDEO MODELING WITH THE BAIR DATASET
+
+We use the action-free version of the BAIR robot pushing dataset (Ebert et al., 2017) that contain videos of a Sawyer robotic arm with resolution 64x64. In the absence of actions, the task of video generation is completely unsupervised with multiple plausible trajectories due to the partial observability of the environment and stochasticity of the robot actions. We train the baseline models, SAVP-VAE, SV2P and SVG-LP to generate 10 target frames, conditioned on 3 input frames. We extract random temporal patches of 4 frames, and train VideoFlow to maximize the log-likelihood of the 4th frame given a context of 3 past frames. We, thus ensure that all models have seen a total of 13 frames during training.
+
+Bits-per-pixel: We estimated the variational bound of the bits-per-pixel on the test set, via importance sampling, from the posteriors for the SAVP-VAE and SV2P models. We find that VideoFlow outperforms these models on bits-per-pixel and report these values in Table 2. We attribute the high values of bits-per-pixel of the baselines to their optimization objective. They do not optimize the variational bound on the log-likelihood directly due to the presence of a $\beta \neq 1$ term in their objective and scheduled sampling (Bengio et al., 2015).
+
+![](images/a683d1e7f1ae30c014fcb1618147921f56b5ab1a13ce574e5e1b417cbbc090af.jpg)  
+Figure 4: For a given set of conditioning frames on the BAIR action-free we sample 100 videos from each of the stochastic video generation models. We choose the video closest to the ground-truth on the basis of PSNR, SSIM and VGG perceptual metrics and report the best possible value for each of these metrics. All the models were trained using ten target frames but are tested to generate 27 frames. For all the reported metrics, higher is better.
+
+Accuracy of the best sample: The BAIR robot-pushing dataset is highly stochastic and the number of plausible futures are high. Each generated video can be super realistic, can represent a plausible future in theory but can be far from the single ground truth video perceptually. To partially overcome this, we follow the metrics proposed in prior work (Babaeizadeh et al., 2017; Lee et al., 2018; Denton & Fergus, 2018) to evaluate our model. For a given set of conditioning frames in the BAIR action-free test-set, we generate 100 videos from each of the stochastic models. We then compute the closest of these generated videos to the ground truth according to three different metrics, PSNR (Peak Signal to
+
+Noise Ratio), SSIM (Structural Similarity) (Wang et al., 2004) and cosine similarity using features obtained from a pretrained VGG network (Dosovitskiy & Brox, 2016; Johnson et al., 2016) and report our findings in Figure 4. This metric helps us understand if the true future lies in the set of all plausible futures according to the video model.
+
+In prior work, (Lee et al., 2018; Babaeizadeh et al., 2017; Denton & Fergus, 2018) effectively tune the pixel-level variance as a hyperparameter and sample from a deterministic decoder. They obtain training stabiltiy and improve sample quality by removing pixel-level noise using this procedure. We can remove pixel-level noise in our VideoFlow model resulting in higher quality videos at the cost of diversity by sampling videos at a lower temperature, analogous to the procedure in (Kingma & Dhariwal, 2018). For a network trained with additive coupling layers, we can sample the $t ^ { t h }$ frame $x _ { t }$ from $P ( x _ { t } | x _ { < t } )$ with a temperature $T$ simply by scaling the standard deviation of the latent gaussian distribution $P ( \boldsymbol { z } _ { t } | \boldsymbol { z } _ { < t } )$ by a factor of $T$ . We report results with both a temperature of 1.0 and the optimal temperature tuned on the validation set using VGG similarity metrics in Figure 4. Additionally, we also applied low-temperature sampling to the latent gaussian priors of SV2P and SAVP-VAE and empirically found it to hurt performance. We report these results in Figure 12
+
+For SAVP-VAE, we notice that the hyperparameters that perform the best on these metrics are the ones that have disappearing arms. For completeness, we report these numbers as well as the numbers for the best performing SAVP models that do not have disappearing arms. Our model with optimal temperature performs better or as well as the SAVP-VAE and SVG-LP models on the VGG-based similarity metrics, which correlate well with human perception (Zhang et al., 2018) and SSIM. Our model with temperature $T = 1 . 0$ is also competent with state-of-the-art video generation models on these metrics. PSNR is explicitly a pixel-level metric, which the VAE models incorporate as part of its optimization objective. VideoFlow on the other-hand models the conditional probability of the joint distribution of frames, hence as expected it underperforms on PSNR.
+
+![](images/7c96ecf49f00cd8a40874e3709c9498b9fc8b9cdb24e6e3baa904512d2a276bb.jpg)  
+Figure 5: We display three different futures for two sets of conditioning frames (left and right) at $T = 0 . 6$ showcasing diversity in outcomes
+
+Diversity and quality in generated samples: For each set of conditioning frames in the test set, we generate 10 videos and compute the mean distance in VGG perceptual space across these 45 different pairs. We average this across the test-set for $T = 1 . 0$ and $T = 0 . 6$ and report these numbers in Figure 3. We also assess the quality of the generated videos at $T = 1 . 0$ and $T = 0 . 6$ , using a real vs fake Amazon Mechanical Turk test and report fooling rates. We observe that VideoFlow outperforms diversity values reported in prior work (Lee et al., 2018) while being competitive in the realism axis. We also find that VideoFlow at $T = 0 . 6$ has the highest fooling rate while being competent with state-of-the-art VAE models in diversity.
+
+On inspection of the generated videos, we find that at lower temperatures, the arm exhibits less random behaviour with the background objects remaining static and clear achieving higher realism scores. At higher temperatures, the motion of arm is much more stochastic, achieving high diversity scores with the background objects becoming much noisier leading to a drop in realism.
+
+Fréchet Video Distance (FVD): We evaluate VideoFlow using the recently proposed Fréchet Video Distance (FVD) metric (Unterthiner et al., 2018), an adaptation of the Fréchet Inception Distance (FID) metric (Heusel et al., 2017) for video generation. (Unterthiner et al., 2018) report results with models trained on a total of 16 frames with 2 conditioning frames; while we train our VideoFlow model on a total of 13 frames with 3 conditioning frames, making our results not directly comparable to theirs. We evaluate FVD for both shorter and longer rollouts in Table 3. We show that, even in the settings that are disadvantageous to VideoFlow, where we compute the FVD on a total of 16 frames, when trained on just 13 frames, VideoFlow performs comparable to SAVP.
+
+<table><tr><td colspan="5"># Frames Seen: Training</td></tr><tr><td>Conditioning</td><td>3</td><td>3</td><td>3</td><td>2</td></tr><tr><td>Total</td><td>13</td><td>13</td><td>13</td><td>16</td></tr><tr><td></td><td colspan="3"># Frames: Evaluation</td><td></td></tr><tr><td>Ground truth</td><td>3</td><td>3</td><td>2</td><td></td></tr><tr><td>Total</td><td>13</td><td>16</td><td>16</td><td>26</td></tr><tr><td>Model</td><td colspan="3">FVD</td><td></td></tr><tr><td>VideoFlow (T=0.8)</td><td>95±4</td><td>127±3</td><td>131±5</td><td>-</td></tr><tr><td>VideoFlow (T=1.0)</td><td>149±6</td><td>221±8</td><td>251±7</td><td>1</td></tr><tr><td>SAVP</td><td>-</td><td>-</td><td>-</td><td>116</td></tr><tr><td>SV2P</td><td>=</td><td>-</td><td>-</td><td>263</td></tr></table>
+
+# 5.3 LATENT SPACE INTERPOLATION
+
+BAIR robot pushing dataset: We encode the first input frame and the last target frame into the latent space using our trained VideoFlow encoder and perform interpolations. We find that the motion of the arm is interpolated in a temporally cohesive fashion between the initial and final position. Further, we use the multi-level latent representation to interpolate representations at a particular level while keeping the representations at other levels fixed. We find that the bottom level interpolates the motion of background objects which are at a smaller scale while the top level interpolates the arm motion.
+
+![](images/aad55d52750b1b98a590db5a07d4d80b527972bc5a8c27149305eeda1edf2561.jpg)  
+Table 3: Fréchet Video Distance:. We report the mean and standard deviation across 5 runs for 3 different frame settings. Results are not directly comparable across models due to the differences between the total number of frames seen during training and the number of conditioning frames.   
+Figure 6: Left: We display interpolations between a) a small blue rectangle and a large yellow rectangle b) a small blue circle and a large yellow circle. Right: We display interpolations between the first input frame and the last target frame of two test videos in the BAIR robot pushing dataset.
+
+Stochastic Movement Dataset: We encode two different shapes with their type fixed but a different size and color into the latent space. We observe that the size of the shape gets smoothly interpolated. During training, we sample the colors of the shapes from a uniform discrete distribution which is reflected in our experiments. We observe that all the colors in the interpolated space lie in the set of colors in the training set.
+
+# 5.4 LONGER PREDICTIONS
+
+We generate 100 frames into the future using our model trained on 13 frames with a temperature of 0.5 and display our results in Figure 7. On the top, even 100 frames into the future, the generated frames remain in the image manifold maintaining temporal consistency. In the presence of occlusions, the arm remains super-sharp but the background objects become noisier and blurrier. Our VideoFlow model has a bijection between the $\mathbf { z } _ { t }$ and $\mathbf { x } _ { t }$ meaning that the latent state $\mathbf { z } _ { t }$ cannot store information other than that present in the frame $\mathbf { x } _ { t }$ . This, in combination with the Markovian assumption in our latent dynamics means that the model can forget objects if they have been occluded for a few frames. In future work, we would address this by incorporating longer memory in our VideoFlow model; for example by parameterizing $N N _ { \theta } ( )$ as a recurrent neural network in our autoregressive prior (eq. 8) or using more memory-efficient backpropagation algorithms for invertible neural networks (Gomez et al., 2017).
+
+![](images/e59075b14cf3cea96145e3da800c6534f60d2202a1632b5473557eea428a6d49.jpg)  
+Figure 7: Left: We generate 100 frames into the future with a temperature of 0.5. The top and bottom row correspond to generated videos in the absence and presence of occlusions respectively. Right: We use VideoFlow to detect the plausibility of a temporally inconsistent frame to occur in the immediate future.
+
+# 5.5 OUT-OF-SEQUENCE DETECTION
+
+We use our trained VideoFlow model, conditioned on 3 frames as explained in Section 5.2, to detect the plausibility of a temporally inconsistent frame to occur in the immediate future. We condition the model on the first three frames of a test-set video $X _ { < 4 }$ to obtain a distribution $P ( X _ { 4 } | X _ { < 4 } )$ over its 4th frame $X _ { 4 }$ . We then compute the likelihood of the $t ^ { \mathrm { t h } }$ frame $X _ { t }$ of the same video to occur as the 4th time-step using this distribution. i.e, $\mathcal { P } ( X _ { 4 } = X _ { t } \vert X _ { < 4 } )$ for $t = 4 \dots 1 3$ . We average the corresponding bits-per-pixel values across the test set and report our findings in Figure 7. We find that our model assigns a monotonically decreasing log-likelihood to frames that are more far out in the future and hence less likely to occur in the 4th time-step.
+
+# 6 OPEN SOURCE CODE AND CHECKPOINTS
+
+We open-source the implementation of our code in the Tensor2Tensor codebase. We additionally open-source various components of our trained VideoFlow model, to evaluate log-likelihood, to generate frames and compute latent codes as reusable TFHub modules
+
+# 7 CONCLUSION AND DISCUSSION
+
+We describe a practically applicable architecture for flow-based video prediction models, inspired by the Glow model for image generation Kingma & Dhariwal (2018), which we call VideoFlow. We introduce a latent dynamical system model that predicts future values of the flow model’s latent state replacing the standard unconditional prior distribution. Our empirical results show that VideoFlow achieves results that are competitive with the state-of-the-art VAE models in stochastic video prediction. Finally, our model optimizes log-likelihood directly making it easy to evaluate while achieving faster synthesis compared to pixel-level autoregressive video models, making our model suitable for practical purposes. In future work, we plan to incorporate memory in VideoFlow to model arbitrary long-range dependencies and apply the model to challenging downstream tasks.
+
+# ACKNOWLEDGEMENTS
+
+We would like to thank Ryan Sepassi and Lukasz Kaiser for their extensive help in using Tensor2Tensor, Oscar Täckström for finding a bug in our evaluation pipeline that improved results across all models, Ruben Villegas for providing code for the SVG-LP baseline and Mostafa Dehghani for providing feedback on a draft of the rebuttal.
+
+# REFERENCES
+
+Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. arXiv preprint arXiv:1710.11252, 2017.
+
+Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1171–1179, 2015.
+
+Byron Boots, Arunkumar Byravan, and Dieter Fox. Learning predictive models of a depth camera & manipulator from raw execution traces. In International Conference on Robotics and Automation (ICRA), 2014.
+
+Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. In Neural Information Processing Systems (NIPS), 2016.
+
+Gustavo Deco and Wilfried Brauer. Higher order statistical decorrelation without information loss. Advances in Neural Information Processing Systems, pp. 247–254, 1995.
+
+Emily Denton and Vighnesh Birodkar. Unsupervised learning of disentangled representations from video. arXiv preprint arXiv:1705.10915, 2017.
+
+Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint arXiv:1802.07687, 2018.
+
+Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using Real NVP. arXiv preprint arXiv:1605.08803, 2016.
+
+Alexey Dosovitskiy and Thomas Brox. Generating images with perceptual similarity metrics based on deep networks. In Advances in Neural Information Processing Systems, pp. 658–666, 2016.
+
+Frederik Ebert, Chelsea Finn, Alex X Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. arXiv preprint arXiv:1710.05268, 2017.
+
+Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In International Conference on Robotics and Automation (ICRA), 2017.
+
+Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in Neural Information Processing Systems, 2016.
+
+Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in Neural Information Processing Systems, pp. 2211–2221, 2017.
+
+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, pp. 2672–2680, 2014.
+
+Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.
+
+Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in neural information processing systems, pp. 6626–6637, 2017.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural computation, 9(8): 1735–1780, 1997.
+
+Catalin Ionescu, Dragos Papava, Vlad Olaru, and Cristian Sminchisescu. Human3. 6m: Large scale datasets and predictive methods for 3d human sensing in natural environments. IEEE transactions on pattern analysis and machine intelligence, 36(7):1325–1339, 2014.
+
+Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision, pp. 694–711. Springer, 2016.
+
+Nal Kalchbrenner, Aäron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. International Conference on Machine Learning (ICML), 2017.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. Proceedings of the 2nd International Conference on Learning Representations, 2013.
+
+Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pp. 10236–10245, 2018.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1106–1114, 2012.
+
+Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv preprint arXiv:1804.01523, 2018.
+
+Yijun Li, Chen Fang, Jimei Yang, Zhaowen Wang, Xin Lu, and Ming-Hsuan Yang. Flow-grounded spatial-temporal video prediction from still images. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 600–615, 2018.
+
+Ziwei Liu, Raymond Yeh, Xiaoou Tang, Yiming Liu, and Aseem Agarwala. Video frame synthesis using deep voxel flow. International Conference on Computer Vision (ICCV), 2017.
+
+William Lotter, Gabriel Kreiman, and David Cox. Deep predictive coding networks for video prediction and unsupervised learning. International Conference on Learning Representations (ICLR), 2017.
+
+Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square error. International Conference on Learning Representations (ICLR), 2016.
+
+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.
+
+Ryan Prenger, Rafael Valle, and Bryan Catanzaro. Waveglow: A flow-based generative network for speech synthesis. CoRR, abs/1811.00002, 2018. URL http://arxiv.org/abs/1811. 00002.
+
+Prajit Ramachandran, Tom Le Paine, Pooya Khorrami, Mohammad Babaeizadeh, Shiyu Chang, Yang Zhang, Mark A Hasegawa-Johnson, Roy H Campbell, and Thomas S Huang. Fast generation for convolutional autoregressive models. arXiv preprint arXiv:1704.06001, 2017.
+
+MarcAurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv preprint arXiv:1412.6604, 2014.
+
+Scott Reed, Aäron van den Oord, Nal Kalchbrenner, Sergio Gómez Colmenarejo, Ziyu Wang, Dan Belov, and Nando de Freitas. Parallel multiscale autoregressive density estimation. arXiv preprint arXiv:1703.03664, 2017.
+
+Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Proceedings of The 32nd International Conference on Machine Learning, pp. 1530–1538, 2015.
+
+Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1278–1286, 2014.
+
+David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017.
+
+Nitish Srivastava, Elman Mansimov, and Ruslan Salakhudinov. Unsupervised learning of video representations using lstms. In International Conference on Machine Learning, 2015.
+
+Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges, 2018.
+
+Aaron Van Den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016.
+
+Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with PixelCNN decoders. In Advances in Neural Information Processing Systems, pp. 4790–4798, 2016a.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016b.
+
+Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with PixelCNN decoders. arXiv preprint arXiv:1606.05328, 2016c.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017.
+
+Ashish Vaswani, Samy Bengio, Eugene Brevdo, Francois Chollet, Aidan N Gomez, Stephan Gouws, Llion Jones, Łukasz Kaiser, Nal Kalchbrenner, Niki Parmar, et al. Tensor2tensor for neural machine translation. arXiv preprint arXiv:1803.07416, 2018.
+
+Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. arXiv preprint arXiv:1706.08033, 2017a.
+
+Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3560–3569. JMLR. org, 2017b.
+
+Carl Vondrick and Antonio Torralba. Generating the future with adversarial transformers. In Computer Vision and Pattern Recognition (CVPR), 2017.
+
+Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Anticipating the future by watching unlabeled video. arXiv preprint arXiv:1504.08023, 2015.
+
+Jacob Walker, Abhinav Gupta, and Martial Hebert. Dense optical flow prediction from a static image. In International Conference on Computer Vision (ICCV), 2015.
+
+Zhou Wang, Alan C Bovik, Hamid R Sheikh, and Eero P Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 2004.
+
+Jianwen Xie, Song-Chun Zhu, and Ying Nian Wu. Synthesizing dynamic patterns by spatial-temporal generative convnet. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017.
+
+Jianwen Xie, Ruiqi Gao, Zilong Zheng, Song-Chun Zhu, and Ying Nian Wu. Learning dynamic generator model by alternating back-propagation through time. Proceedings of the AAAI Conference on Artificial Intelligence, 33:5498–5507, Jul 2019. ISSN 2159-5399. doi: 10.1609/aaai.v33i01. 33015498. URL http://dx.doi.org/10.1609/aaai.v33i01.33015498.
+
+Jianwen Xie, Yang Lu, Ruiqi Gao, Song-Chun Zhu, and Ying Nian Wu. Cooperative training of descriptor and generator networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 42(1):27–45, Jan 2020. ISSN 1939-3539. doi: 10.1109/tpami.2018.2879081. URL http://dx.doi.org/10.1109/TPAMI.2018.2879081.
+
+SHI Xingjian, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional lstm network: A machine learning approach for precipitation nowcasting. In Advances in Neural Information Processing Systems, 2015.
+
+Tianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. In Advances in Neural Information Processing Systems, 2016.
+
+Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. arXiv preprint, 2018.
+
+# A MOVING MNIST - QUALITATIVE EXPERIMENTS
+
+![](images/1ae26f8204c28db75dd59209d1dcc0d6dd90682a57d18be970e0ad56f9a81cbb.jpg)  
+Figure 8: We display ten frame rollouts conditioned on a single frame on the Moving MNIST dataset.
+
+Similar to the Stochastic Movement Dataset as described in Section 5.1, we extract random temporal patches of 2 frames on the Moving MNIST dataset (Srivastava et al., 2015). We train our VideoFlow model to maximize the log-likelihood of the second frame, given the first. Our rollouts over 10 frames capture realistic digit movement.
+
+# B HUMAN3.6M - QUALITATIVE EXPERIMENTS
+
+We model the Human3.6M dataset (Ionescu et al., 2014), by maximizing the log-likelihood of the 4th frame given the first three frames, in a random temporal patch of 4 frames. We observe that on this dataset, our model fails to capture reasonable human motion. We hope that by increasing model capacity and using more expressive priors, we can acheive better performance on this dataset in the future.
+
+# C DISCRETIZATION AND UNIFORM QUANTIZATION
+
+Let $\mathcal { D } = \{ \mathbf { x } ^ { ( i ) } \} _ { i = 1 } ^ { N }$ be our dataset of i.i.d. observations of a random variable $\mathbf { x }$ with an unknown true distribution $p ^ { * } ( \mathbf { x } )$ . Our data consist of 8-bit videos, with each dimension rescaled to the domain $[ 0 , 2 5 5 / 2 5 6 ]$ . We add a small amount of uniform noise to the data, $\mathbf { u } \sim \mathcal { U } ( 0 , 1 / 2 5 6 . )$ , matching its discretization level (Dinh et al., 2016; Kingma & Dhariwal, 2018). Let $q ( \mathbf { x } )$ be the resulting empirical distribution corresponding to this scaling and addition of noise. Note that additive noise is required to prevent $q ( \mathbf { x } )$ from having infinite densities at the datapoints, which can result in ill-behaved optimization of the log-likelihood; it also allows us to recast maximization of the log-likelihood as minimization of a KL divergence.
+
+![](images/0b91185728f0b682c869ab816f2e0acfa8d631d2f9f9401e63f3241c1bc2e2cc.jpg)  
+Figure 9: We display ten frame rollouts conditioned on 3 frames on the Human3.6M dataset.
+
+# D RESIDUAL NETWORK ARCHITECTURE
+
+Here we’ll describe the architecture for the residual network N Nθ() that maps z(l)<t, z(>t to $( \mu _ { t } ^ { ( l ) } , \log \sigma _ { t } ^ { ( l ) } )$ (Left: Figure 10). As shown in the left of Figure 10, let $\mathbf { h } _ { t } ^ { ( > l ) }$ be the tensor representing $\mathbf { z } _ { t } ^ { ( > l ) }$ after the split operation between levels in the multi-scale architecture. We apply a $1 \times 1$ convolution over $\mathbf { h } _ { t } ^ { ( > l ) }$ and concatenate this across channels to each laobtain $( ( W \mathbf { h } _ { t } ^ { ( > l ) } ; \mathbf { z } _ { t - 1 } ^ { ( l ) } ) , ( W \mathbf { h } _ { t } ^ { ( > l ) } ; \mathbf { z } _ { t - 2 } ^ { ( l ) } ) \cdot \cdot \cdot ( W \mathbf { h } _ { t } ^ { ( > l ) } ; \mathbf { z } _ { t - n } ^ { ( l ) } ) )$ l independently. In this way, we. We transform these values into $( \mu _ { t } ^ { ( l ) } , \log \sigma _ { t } ^ { ( l ) } )$ via a stack of residual blocks. We obtain a reduction in parameter count by sharing parameters across every 2 time-steps via 3-D convolutions in our residual blocks.
+
+As shown in the right of Figure 10, each 3-D residual block consists of three layers. The first layer has a filter size of $2 \mathrm { x } 3 \mathrm { x } 3 $ with 512 output channels followed by a ReLU activation. The second layer has two $1 \times 1 \times 1$ convolutions via the Gated Activation Unit Van Den Oord et al. (2016); van den Oord et al. (2016a). The third layer has a filter size of $2 \times 3 \times 3$ with the number of output channels determined by the level. This block is replicated three times in parallel, with dilation rates 1, 2 and 4, after which the results of each block, in addition to the input of the residual block, are summed.
+
+The first two layers are initialized using a Gaussian distribution and the last layer is initialized to zeroes. In that way, the residual network behaves as an identity network during initialization allowing stable optimization. After applying a sequence of residual blocks, we use the last temporal activation that should capture all context. We apply a final $1 \times 1$ convolution to this activation to obtain $( \Delta \mathbf { z } _ { t } ^ { ( l ) } , \log \sigma _ { t } ^ { ( l ) } )$ . We then add $\Delta \mathbf { z } _ { t } ^ { ( l ) }$ to $\mathbf { z } _ { t - 1 } ^ { ( l ) }$ to a temporal skip connection to output $\mu _ { t } ^ { ( l ) }$ . This way, the network learns to predict the change in latent variables for a given level. We have provided visualizations of the network architecture in this website
+
+# E ABLATION STUDIES
+
+Through an ablation study, we experimentally evaluate the importance of the following components of our VideoFlow model: (1) the use of temporal skip connections, (2) the use Gated Activation Unit (GATU) instead of ReLUs in the residual network and (3) the use of dilations in $N N _ { \pmb \theta } ( \pmb )$ in Section D
+
+We start with a VideoFlow model with 256 channels in the coupling layer, 16 steps of flow and remove the components mentioned above to create our baseline. We use four different combinations of our components (described in Fig. 11) and keep the rest of the hyperparameters fixed across those combinations. For each combination we plot the mean bits-per-pixel on the holdout BAIR-action free dataset over $3 0 0 \mathrm { K }$ training steps for both affine and additive coupling in Figure 11. For both the coupling layers, we observe that the VideoFlow model with all the components provide a significant boost in bits-per-pixel over our baseline.
+
+![](images/5c62f7722b1bac9a52aaa15acab7092dd9e004f373701395b671ba2a6b7d000b.jpg)  
+Figure 10: Left: We predict a gaussian distribution over $\mathbf { z } _ { t } ^ { ( l ) }$ via a 3-D Residual network conditioned on $\mathbf { z } _ { < t } ^ { ( l ) }$ and $\mathbf { z } _ { t } ^ { ( > l ) }$ . Right: Our 3-D residual network architecture is augmented with dilations and gated activation units improving performance.
+
+![](images/7a3a293bf33b4240af6209c8aba92fa7184ba01c0c8b6a6a636b8cac0096329f.jpg)  
+Figure 11: B: baseline, A: Temporal Skip Connection, C: Dilated Convolutions $^ +$ GATU, D: Dilation Convolutions $^ +$ Temporal Skip Connection, E: Dilation Convolutions $^ +$ Temporal Skip Connection $^ +$ GATU. We plot the holdout bits-per-pixel on the BAIR action-free dataset for different ablations of our VideoFlow model.
+
+We also note that other combinations—dilated convolutions $+ \mathrm { G A T U }$ (C) and dilated convolutions $^ +$ the temporal skip connection —improve over the baseline. Finally, we experienced that increasing the receptive field in $N N _ { \pmb \theta } ( \pmb )$ using dilated convolutions alone in the absence of the temporal skip connection or the GATU makes training highly unstable.
+
+# F EFFECT OF TEMPERATURE ON SAVP-VAE AND SV2P
+
+We repeat our evaluations described in Figure 4 applying low temperature to the latent gaussian priors of SV2P and SAVP-VAE. We empirically find that decreasing temperature from 1.0 to 0.0 monotonically decreases the performance of the VAE models. Our insight is that the VideoFlow model gains by low-temperature sampling due to the following reason. At lower T, we obtain a tradeoff between a performance gain by noise removal from the background and a performance hit due to reduced stochasticity of the robot arm. On the other hand, the VAE models have a clear but slightly blurry background throughout from $T = 1 . 0$ to $T = 0 . 0$ . Reducing T in this case, solely reduces the stochasticity of the arm motion thus hurting performance.
+
+![](images/5bb63061df6ae8787f040753d2efd8153f7bb8335a1c7b8d8c4686ae0fbd1cb8.jpg)  
+Figure 12: We repeat our evaluations described on the SV2P and SAVP-VAE model in Figure 4 using temperatures from 0.0 to 1.0 while sampling from the latent gaussian prior.
+
+# G LIKELIHOOD VS QUALITY
+
+![](images/d738542bde975a00b392ea89c391243f5b3697e11cff5cdb08c216e539cfd2cc.jpg)  
+Figure 13: We provide a comparison between training progression (measured in the mean bits-per-pixel objective on the test-set) and the quality of generated videos.
+
+We show correlation between training progression (measured in bits per pixel) and quality of the generated videos in Figure 13. We display the videos generated by conditioning on frames from the test set for three different values of bits-per-pixel on the test-set. As we approach lower bits-per-pixel, our VideoFlow model learns to model the structure of the arm with high quality as well as its motion resulting in high quality video.
+
+# H VIDEOFLOW - BAIR HYPERPARAMETERS
+
+# H.1 QUANTITATIVE - BITS-PER-PIXEL
+
+To report bits-per-pixel we use the following set of hyperparameters. We use a learning rate schedule of linear warmup for the first 10000 steps and apply a linear-decay schedule for the last 150000 steps.
+
+<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Flow levels</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Flow steps per level</td><td rowspan=1 colspan=1>24</td></tr><tr><td rowspan=1 colspan=1>Coupling</td><td rowspan=1 colspan=1>Affine</td></tr><tr><td rowspan=1 colspan=1>Number of coupling layer channels</td><td rowspan=1 colspan=1>512</td></tr><tr><td rowspan=1 colspan=1>Optimier</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>40</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>3e-4</td></tr><tr><td rowspan=1 colspan=1>Number of 3-D residual blocks</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>Numberof 3-D residualchannels</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Training steps</td><td rowspan=1 colspan=1>600K</td></tr></table>
+
+# H.2 QUALITATIVE EXPERIMENTS
+
+For all qualitative experiments and quantitative comparisons with the baselines, we used the following sets of hyperparameters.
+
+<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Flowlevels</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Flow steps per level</td><td rowspan=1 colspan=1>24</td></tr><tr><td rowspan=1 colspan=1>Coupling</td><td rowspan=1 colspan=1>Additive</td></tr><tr><td rowspan=1 colspan=1>Number of coupling layer channels</td><td rowspan=1 colspan=1>392</td></tr><tr><td rowspan=1 colspan=1>Optimier</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>40</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>3e-4</td></tr><tr><td rowspan=1 colspan=1>Numberof 3-D residualblocks</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>Number of 3-D residual channels</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Training steps</td><td rowspan=1 colspan=1>500K</td></tr></table>
+
+# I HYPERPARAMETER GRID FOR THE BASELINE VIDEO MODELS.
+
+We train all our baseline models for 300K steps using the Adam optimizer. Our models were tuned using the maximum VGG cosine similarity metric with the ground-truth across 100 decodes.
+
+SAVP-VAE and SV2P: We use three values of latent loss multiplier 1e-3, 1e-4 and 1e-5. For the SAVP-VAE model, we additionally apply linear decay on the learning rate for the last 100K steps. SAVP-GAN: We tune the gan loss multiplier and the learning rate on a logscale from 1e-2 to 1e-4 and 1e-3 to 1e-5 respectively.
+
+# J CORRELATION BETWEEN VGG PERCEPTUAL SIMILARITY AND BITS-PER-PIXEL
+
+We plot correlation between cosine similarity using a pretrained VGG network and bits-per-pixel using our trained VideoFlow model. We compare $\bar { \mathcal { P } } ( X _ { 4 } ^ { - } = X _ { t } | X _ { < 4 } )$ as done in Section 5.5 and the VGG cosine similarity between $X _ { 4 }$ and $X _ { t }$ for $t = 4 \dots 1 3$ . We report our results for every video in the test set in Figure 15. We notice a weak correlation between VGG perceptual metrics and bits-per-pixel with a correlation factor of $- 0 . 5 1$ .
+
+![](images/92700e01fc04c693d4825d020ac49caa2609059e9174954bcaf7e0480c1bdb49.jpg)  
+Figure 14: We compare $\mathcal { P } ( X _ { 4 } = X _ { t } \vert X _ { < 4 } )$ and VGG cosine similarity between $X _ { 4 }$ and $X _ { t }$ for $t = 4 \dots 1 3$
+
+# K VIDEOFLOW: LOW PARAMETER REGIME
+
+We repeated our evaluations described in Figure 4, with a smaller version of our VideoFlow model with $4 \mathbf { x }$ parameter reduction. Our model remains competetive with SVG-LP on the VGG perceptual metrics.
+
+![](images/c076a1a61ad38e20102a452d42cf85215f6e6f8034a16c569e2e4227bb7e7cc0.jpg)  
+Figure 15: We repeat our evaluations described in Figure 4 with a smaller version of our VideoFlow model.

parse/train/rJgUfTEYvH/rJgUfTEYvH_content_list.json

@@ -0,0 +1,2080 @@
+[
+    {
+        "type": "text",
+        "text": "VIDEOFLOW: A CONDITIONAL FLOW-BASED MODEL FOR STOCHASTIC VIDEO GENERATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            825,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Manoj Kumar∗, Mohammad Babaeizadeh, Dumitru Erhan, Chelsea Finn, Sergey Levine, Laurent Dinh, Durk Kingma ",
+        "bbox": [
+            183,
+            169,
+            598,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Google Research, Brain Team {mechcoder,mbz,dumitru,chelseaf,slevine,laurentdinh,durk}@google.com ",
+        "bbox": [
+            183,
+            199,
+            849,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Generative models that can model and predict sequences of future events can, in principle, learn to capture complex real-world phenomena, such as physical interactions. However, a central challenge in video prediction is that the future is highly uncertain: a sequence of past observations of events can imply many possible futures. Although a number of recent works have studied probabilistic models that can represent uncertain futures, such models are either extremely expensive computationally as in the case of pixel-level autoregressive models, or do not directly optimize the likelihood of the data. To our knowledge, our work is the first to propose multi-frame video prediction with normalizing flows, which allows for direct optimization of the data likelihood, and produces high-quality stochastic predictions. We describe an approach for modeling the latent space dynamics, and demonstrate that flow-based generative models offer a viable and competitive approach to generative modeling of video. ",
+        "bbox": [
+            233,
+            294,
+            766,
+            474
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            502,
+            336,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Exponential progress in the capabilities of computational hardware, paired with a relentless effort towards greater insights and better methods, has pushed the field of machine learning from relative obscurity into the mainstream. Progress in the field has translated to improvements in various capabilities, such as classification of images (Krizhevsky et al., 2012), machine translation (Vaswani et al., 2017) and super-human game-playing agents (Mnih et al., 2013; Silver et al., 2017), among others. However, the application of machine learning technology has been largely constrained to situations where large amounts of supervision is available, such as in image classification or machine translation, or where highly accurate simulations of the environment are available to the learning agent, such as in game-playing agents. An appealing alternative to supervised learning is to utilize large unlabeled datasets, combined with predictive generative models. In order for a complex generative model to be able to effectively predict future events, it must build up an internal representation of the world. For example, a predictive generative model that can predict future frames in a video would need to model complex real-world phenomena, such as physical interactions. This provides an appealing mechanism for building models that have a rich understanding of the physical world, without any labeled examples. Videos of real-world interactions are plentiful and readily available, and a large generative model can be trained on large unlabeled datasets containing many video sequences, thereby learning about a wide range of real-world phenoma. Such a model could be useful for learning representations for further downstream tasks (Mathieu et al., 2016), or could even be used directly in applications where predicting the future enables effective decision making and control, such as robotics (Finn et al., 2016). A central challenge in video prediction is that the future is highly uncertain: a short sequence of observations of the present can imply many possible futures. Although a number of recent works have studied probabilistic models that can represent uncertain futures, such models are either extremely expensive computationally (as in the case of pixel-level autoregressive models), or do not directly optimize the likelihood of the data. ",
+        "bbox": [
+            174,
+            534,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we study the problem of stochastic prediction, focusing specifically on the case of conditional video prediction: synthesizing raw RGB video frames conditioned on a short context of past observations (Ranzato et al., 2014; Srivastava et al., 2015; Vondrick et al., 2015; Xingjian et al., 2015; Boots et al., 2014). Specifically, we propose a new class of video prediction models that can provide exact likelihoods, generate diverse stochastic futures, and accurately synthesize realistic and high-quality video frames. The main idea behind our approach is to extend flow-based generative models (Dinh et al., 2014; 2016) into the setting of conditional video prediction. To our knowledge, flow-based models have been applied only to generation of non-temporal data, such as images (Kingma & Dhariwal, 2018), and to audio sequences (Prenger et al., 2018). Conditional generation of videos presents its own unique challenges: the high dimensionality of video sequences makes them difficult to model as individual datapoints. Instead, we learn a latent dynamical system model that predicts future values of the flow model’s latent state. This induces Markovian dynamics on the latent state of the system, replacing the standard unconditional prior distribution. We further describe a practically applicable architecture for flow-based video prediction models, inspired by the Glow model for image generation (Kingma & Dhariwal, 2018), which we call VideoFlow. ",
+        "bbox": [
+            176,
+            873,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            284
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our empirical results show that VideoFlow achieves results that are competitive with the state-ofthe-art in stochastic video prediction on the action-free BAIR dataset, with quantitative results that rival the best VAE-based models. VideoFlow also produces excellent qualitative results, and avoids many of the common artifacts of models that use pixel-level mean-squared-error for training (e.g., blurry predictions), without the challenges associated with training adversarial models. Compared to models based on pixel-level autoregressive prediction, VideoFlow achieves substantially faster test-time image synthesis 1, making it much more practical for applications that require real-time prediction, such as robotic control (Finn & Levine, 2017). Finally, since VideoFlow directly optimizes the likelihood of training videos, without relying on a variational lower bound, we can evaluate its performance directly in terms of likelihood values. ",
+        "bbox": [
+            174,
+            290,
+            825,
+            429
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            450,
+            343,
+            467
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Early work on prediction of future video frames focused on deterministic predictive models (Ranzato et al., 2014; Srivastava et al., 2015; Vondrick et al., 2015; Xingjian et al., 2015; Boots et al., 2014). Much of this research on deterministic models focused on architectural changes, such as predicting high-level structure (Villegas et al., 2017b), energy-based models (Xie et al., 2017), generative cooperative nets (Xie et al., 2020), ABPTT (Xie et al., 2019), incorporating pixel transformations (Finn et al., 2016; De Brabandere et al., 2016; Liu et al., 2017) and predictive coding architectures (Lotter et al., 2017), as well as different generation objectives (Mathieu et al., 2016; Vondrick & Torralba, 2017; Walker et al., 2015) and disentangling representations (Villegas et al., 2017a; Denton & Birodkar, 2017). With models that can successfully model many deterministic environments, the next key challenge is to address stochastic environments by building models that can effectively reason over uncertain futures. Real-world videos are always somewhat stochastic, either due to events that are inherently random, or events that are caused by unobserved or partially observable factors, such as off-screen events, humans and animals with unknown intentions, and objects with unknown physical properties. In such cases, since deterministic models can only generate one future, these models either disregard potential futures or produce blurry predictions that are the superposition or averages of possible futures. ",
+        "bbox": [
+            174,
+            483,
+            826,
+            704
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A variety of methods have sought to overcome this challenge by incorporating stochasticity, via three types of approaches: models based on variational auto-encoders (VAEs) (Kingma & Welling, 2013; Rezende et al., 2014), generative adversarial networks (Goodfellow et al., 2014), and autoregressive models (Hochreiter & Schmidhuber, 1997; Graves, 2013; van den Oord et al., 2016b;c; Van Den Oord et al., 2016). ",
+        "bbox": [
+            174,
+            712,
+            825,
+            781
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Among these models, techniques based on variational autoencoders which optimize an evidence lower bound on the log-likelihood have been explored most widely (Babaeizadeh et al., 2017; Denton & Fergus, 2018; Lee et al., 2018; Xue et al., 2016; Li et al., 2018). To our knowledge, the only prior class of video prediction models that directly maximize the log-likelihood of the data are autoregressive models (Hochreiter & Schmidhuber, 1997; Graves, 2013; van den Oord et al., 2016b;c; Van Den Oord et al., 2016), that generate the video one pixel at a time (Kalchbrenner et al., 2017). However, synthesis with such models is typically inherently sequential, making synthesis substantially inefficient on modern parallel hardware. Prior work has aimed to speed up training and synthesis with such auto-regressive models (Reed et al., 2017; Ramachandran et al., 2017). However, (Babaeizadeh et al., 2017) show that the predictions from these models are sharp but noisy and that the proposed VAE model produces substantially better predictions, especially for longer horizons. In contrast to autoregressive models, we find that our proposed method exhibits faster sampling, while still directly optimizing the log-likelihood and producing high-quality long-term predictions. ",
+        "bbox": [
+            174,
+            789,
+            825,
+            887
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/0027199eb377c5633427a680c43a111c27c2795241099f59d443abe1ba5557b4.jpg",
+        "image_caption": [
+            "Figure 1: Left: Multi-scale prior The flow model uses a multi-scale architecture using several levels of stochastic variables. Right: Autoregressive latent-dynamic prior The input at each timestep $\\mathbf { x } _ { t }$ is encoded into multiple levels of stochastic variables $( \\mathbf { z } _ { t } ^ { ( 1 ) } , \\ldots , \\mathbf { z } _ { t } ^ { ( L ) } )$ z(L)t ). We model those levels through a sequential process $\\begin{array} { r } { \\prod _ { t } \\prod _ { l } p ( \\mathbf { \\hat { z } } _ { t } ^ { ( l ) } \\mid \\mathbf { z } _ { < t } ^ { ( l ) } , \\mathbf { z } _ { t } ^ { ( > l ) } ) } \\end{array}$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            228,
+            101,
+            764,
+            267
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            369,
+            825,
+            454
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRELIMINARIES: FLOW-BASED GENERATIVE MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            479,
+            658,
+            496
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Flow-based generative models (Dinh et al., 2014; 2016) have a unique set of advantages: exact latentvariable inference, exact log-likelihood evaluation, and parallel sampling. In flow-based generative models (Dinh et al., 2014; 2016), we infer the latent variable $\\mathbf { z }$ corresponding to a datapoint $\\mathbf { x }$ , by transforming $\\mathbf { x }$ through a composition of invertible functions $\\mathbf { f } = \\mathbf { f } _ { 1 } \\circ \\mathbf { f } _ { 2 } \\circ \\cdots \\circ \\mathbf { f } _ { K }$ . We assume a tractable prior $p _ { \\pmb { \\theta } } ( \\mathbf { z } )$ over latent variable $\\mathbf { z }$ , for eg. a Logistic or a Gaussian distribution. By constraining the transformations to be invertible, we can compute the log-likelihood of $\\mathbf { x }$ exactly using the change of variables rule. Formally, ",
+        "bbox": [
+            173,
+            513,
+            825,
+            613
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60131c79d56ff54374141232da9f459ab590cdf108e8c5a6c8b504aea3a22430.jpg",
+        "text": "$$\n\\log p _ { \\pmb \\theta } ( \\mathbf x ) = \\log p _ { \\pmb \\theta } ( \\mathbf z ) + \\sum _ { i = 1 } ^ { K } \\log | \\operatorname* { d e t } ( d \\mathbf h _ { i } / d \\mathbf h _ { i - 1 } ) |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            643,
+            669,
+            686
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { h } _ { 0 } = \\mathbf { x }$ , $\\mathbf { h } _ { i } = \\mathbf { f } _ { i } ( \\mathbf { h } _ { i - 1 } )$ , $\\mathbf { h } _ { K } = \\mathbf { z }$ and $| \\operatorname* { d e t } ( d \\mathbf { h } _ { i } / d \\mathbf { h } _ { i - 1 } |$ is the Jacobian determinant when $\\mathbf { h } _ { i - 1 }$ is transformed to $\\mathbf { h } _ { i }$ by $\\mathbf { f } _ { i }$ . We learn the parameters of $\\mathbf { f } _ { 1 } \\ldots . \\mathbf { f } _ { K }$ by maximizing the log-likelihood, i.e Equation (1), over a training set. Given $\\mathbf { g } = \\mathbf { f } ^ { - 1 }$ , we can now generate a sample $\\hat { \\bf x }$ from the data distribution, by sampling $\\mathbf { z } \\sim p _ { \\pmb { \\theta } } ( \\mathbf { z } )$ and computing $\\hat { \\mathbf { x } } = \\mathbf { g } ( \\mathbf { z } )$ . ",
+        "bbox": [
+            173,
+            705,
+            825,
+            762
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 PROPOSED ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            433,
+            804
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We propose a generative flow for video, using the standard multi-scale flow architecture in (Dinh et al., 2016; Kingma & Dhariwal, 2018) as a building block. In our model, we break up the latent space $\\mathbf { z }$ into separate latent variables per timestep: $\\mathbf { z } = \\{ \\mathbf { z } _ { t } \\} _ { t = 1 } ^ { T }$ . The latent variable $\\mathbf { z } _ { t }$ at timestep $t$ is an invertible transformation of a corresponding frame of video: $\\mathbf { x } _ { t } = \\mathbf { g } _ { \\theta } ( \\mathbf { z } _ { t } )$ . Furthermore, like in (Dinh et al., 2016; Kingma & Dhariwal, 2018), we use a multi-scale architecture for ${ \\bf g } _ { \\pmb { \\theta } } ( { \\bf z } _ { t } )$ (Fig. 1): the latent variable $\\mathbf { z } _ { t }$ is composed of a stack of multiple levels: where each level $l$ encodes information about frame $\\mathbf { x } _ { t }$ at a particular scale: $\\mathbf { z } _ { t } = \\{ \\mathbf { z } _ { t } ^ { ( l ) } \\} _ { l = 1 } ^ { \\bar { L } }$ , one component $\\mathbf { z } _ { t } ^ { ( l ) }$ per level. ",
+        "bbox": [
+            173,
+            821,
+            825,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first briefly describe the invertible transformations used in the multi-scale architecture to infer $\\{ \\mathbf { z } _ { t } ^ { ( l ) } \\} _ { l = 1 } ^ { L } = \\mathbf { f } _ { \\pmb { \\theta } } ( \\mathbf { x } _ { t } )$ and refer to (Dinh et al., 2016; Kingma & Dhariwal, 2018) for more details. For convenience, we omit the subscript $t$ in this subsection. We choose invertible transformations whose Jacobian determinant in Equation 1 is simple to compute, that is a triangular matrix, diagonal matrix or a permutation matrix as explored in prior work (Rezende & Mohamed, 2015; Deco & Brauer, 1995). For permutation matrices, the Jacobian determinant is one and for triangular and diagonal Jacobian matrices, the determinant is simply the product of diagonal terms. ",
+        "bbox": [
+            173,
+            128,
+            826,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "• Actnorm: We apply a learnable per-channel scale and shift with data-dependent initialization.   \n• Coupling: We split the input $y$ equally across channels to obtain $y _ { 1 }$ and $y _ { 2 }$ . We compute $z _ { 2 } = f ( y _ { 1 } ) * y _ { 2 } + g ( y _ { 1 } )$ where $f$ and $g$ are deep networks. We concat $y _ { 1 }$ and $z _ { 2 }$ across channels.   \n• SoftPermute: We apply a 1x1 convolution that preserves the number of channels.   \n• Squeeze: We reshape the input from $H \\times W \\times C$ to $H / 2 \\times W / 2 \\times 4 C$ which allows the flow to operate on a larger receptive field. ",
+        "bbox": [
+            215,
+            243,
+            825,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We infer the latent variable $z ^ { ( l ) }$ at level $l$ using: ",
+        "bbox": [
+            174,
+            371,
+            483,
+            386
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e0a8e344d4be3360065c62201a78ec478073e132ed513a01d41e49b1631e57f.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\operatorname { F l o w } ( y ) = \\operatorname { C o u p l i n g } ( \\operatorname { S o f t P e r m u t e } ( \\operatorname { A c t n o r m } ( y ) ) ) ) \\times N } \\\\ & { \\operatorname { F l o w } _ { \\mathrm { 1 } } ( y ) = \\operatorname { S p l i t } ( \\operatorname { F l o w } ( \\operatorname { S q u e e z e } ( y ) ) ) } \\\\ & { ( \\mathbf { h } ^ { ( > l ) } , \\mathbf { z } ^ { l } )  \\operatorname { F l o w } _ { \\mathrm { 1 } } ( \\mathbf { h } ^ { ( > l - 1 ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            312,
+            392,
+            683,
+            452
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $N$ is the number of steps of flow. In Equation (3), via Split, we split the output of Flow equally across channels into $\\mathbf { h } ^ { ( > l ) }$ , the input to $\\mathrm { F l o w } _ { ( \\mathrm { l + 1 } ) } ( . )$ and $z ^ { ( l ) }$ , the latent variable at level $l$ . We, thus enable the flows at higher levels to operate on a lower number of dimensions and larger scales. When $l = 1$ , $\\mathbf { h } ^ { ( > l - 1 ) }$ is just the input frame $x$ and for $l = L$ we omit the Split operation. Finally, our multi-scale architecture $\\mathbf { f } _ { \\pmb { \\theta } } ( \\mathbf { x } _ { t } )$ is a composition of the flows at multiple levels from $l = 1 \\ldots L$ from which we obtain our latent variables i.e $\\{ \\mathbf { z } _ { t } ^ { ( l ) } \\} _ { l = 1 } ^ { L }$ . ",
+        "bbox": [
+            173,
+            463,
+            826,
+            556
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 AUTOREGRESSIVE LATENT DYNAMICS MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            571,
+            534,
+            585
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We use the multi-scale architecture described above to infer the set of corresponding latent variables for each individual frame of the video: $\\{ \\mathbf { z } _ { t } ^ { ( l ) } \\} _ { l = 1 } ^ { L } = \\mathbf { f } _ { \\pmb { \\theta } } ( \\mathbf { x } _ { t } )$ ; see Figure 1 for an illustration. As in Equation (1), we need to choose a form of latent prior $p _ { \\pmb { \\theta } } ( \\mathbf { z } )$ . We use the following autoregressive factorization for the latent prior: ",
+        "bbox": [
+            173,
+            595,
+            825,
+            656
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cb3760afb78626fb3f14de3229b84db0a23362a5efe9914b03b49464f86ac4df.jpg",
+        "text": "$$\np _ { \\pmb { \\theta } } ( \\mathbf { z } ) = \\prod _ { t = 1 } ^ { T } p _ { \\pmb { \\theta } } ( \\mathbf { z } _ { t } | \\mathbf { z } _ { < t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            662,
+            580,
+            707
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { z } _ { < t }$ denotes the latent variables of frames prior to the $t$ -th timestep: $\\left\\{ \\mathbf { z } _ { 1 } , . . . , \\mathbf { z } _ { t - 1 } \\right\\}$ . We specify the conditional prior $p _ { \\pmb { \\theta } } ( \\mathbf { z } _ { t } | \\mathbf { z } _ { < t } )$ as having the following factorization: ",
+        "bbox": [
+            171,
+            713,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e61a318627259f23efd58386837a6fed65a504de15b6afe174b709f1537b504e.jpg",
+        "text": "$$\np _ { \\pmb { \\theta } } \\big ( \\mathbf { z } _ { t } \\big | \\mathbf { z } _ { < t } \\big ) = \\prod _ { l = 1 } ^ { L } p _ { \\pmb { \\theta } } \\big ( \\mathbf { z } _ { t } ^ { ( l ) } \\big | \\mathbf { z } _ { < t } ^ { ( l ) } , \\mathbf { z } _ { t } ^ { ( > l ) } \\big )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            748,
+            620,
+            792
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where z(l)<t is the set of latent variables at previous timesteps and at the same level $l$ , while $\\mathbf { z } _ { t } ^ { ( > l ) }$ is the set of latent variables at the same timestep and at higher levels. See Figure 1 for a graphical illustration of the dependencies. ",
+        "bbox": [
+            174,
+            800,
+            825,
+            845
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We let each $p _ { \\pmb { \\theta } } ( \\mathbf { z } _ { t } ^ { ( l ) } | \\mathbf { z } _ { < t } ^ { ( l ) } , \\mathbf { z } _ { t } ^ { ( > l ) } )$ be a conditionally factorized Gaussian density: ",
+        "bbox": [
+            171,
+            852,
+            687,
+            871
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7445babad4482e309d07729b5e7b6b57fea97161d4b46b4382c32621c044f69c.jpg",
+        "text": "$$\n\\begin{array} { r l } & { p _ { \\pmb { \\theta } } ( \\mathbf { z } _ { t } ^ { ( l ) } | \\mathbf { z } _ { < t } ^ { ( l ) } , \\mathbf { z } _ { t } ^ { ( > l ) } ) = \\mathcal { N } ( \\mathbf { z } _ { t } ^ { ( l ) } ; \\pmb { \\mu } , \\sigma ) } \\\\ & { \\quad \\mathrm { w h e r e } \\ ( \\pmb { \\mu } , \\log \\sigma ) = N N _ { \\pmb { \\theta } } ( \\mathbf { z } _ { < t } ^ { ( l ) } , \\mathbf { z } _ { t } ^ { ( > l ) } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            877,
+            632,
+            922
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/51696ea01196c986a78c881285ce5248e51c7f8c105a4ef82d0e0cf3b20f1c30.jpg",
+        "table_caption": [
+            "Table 1: We compare the realism of the generated trajectories using a real-vs-fake 2AFC Amazon Mechanical Turk with SAVP-VAE and SV2P. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Fooling rate</td></tr><tr><td>SAVP-VAE</td><td>16.4 %</td></tr><tr><td>VideoFlow</td><td>31.8 %</td></tr><tr><td>SV2P</td><td>17.5 %</td></tr></table>",
+        "bbox": [
+            236,
+            123,
+            436,
+            185
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d35db32dbe0a36e17916e99e637ed2949deae79ea445ab96809982139e8eebab.jpg",
+        "image_caption": [
+            "Figure 2: We condition the VideoFlow model with the frame at $\\mathrm { \\Delta t } = 1$ and display generated trajectories at $\\mathbf { t } = 2$ and $\\mathrm { t } = 3$ for three different shapes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            594,
+            103,
+            751,
+            205
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $N N _ { \\theta } ( . )$ is a deep 3-D residual network (He et al., 2015) augmented with dilations and gated activation units and modified to predict the mean and log-scale. We describe the architecture and our ablations of the architecture in Section D and E of the appendix. ",
+        "bbox": [
+            176,
+            289,
+            823,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In summary, the log-likelhood objective of Equation (1) has two parts. The invertible multi-scale architecture contributes $\\begin{array} { r l } { ~ } & { { } \\sum _ { i = 1 } ^ { K } \\log | \\operatorname* { d e t } ( d \\mathbf { h } _ { i } / d \\mathbf { h } _ { i - 1 } ) | } \\end{array}$ via the sum of the log Jacobian determinants of the invertible transformations mapping the video $\\{ { \\bf x } _ { t } \\} _ { t = 1 } ^ { T }$ to $\\{ \\mathbf { z } _ { t } \\} _ { t = 1 } ^ { T }$ ; the latent dynamics model contributes $\\log p \\pmb { \\theta } ( \\mathbf { z } )$ , i.e Equation (5). We jointly learn the parameters of the multi-scale architecture and latent dynamics model by maximizing this objective. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that in our architecture we have chosen to let the prior $p _ { \\pmb { \\theta } } ( \\mathbf { z } )$ , as described in eq. (5), model temporal dependencies in the data, while constraining the flow $\\mathbf { g } _ { \\theta }$ to act on separate frames of video. We have experimented with using 3-D convolutional flows, but found this to be computationally overly expensive compared to an autoregressive prior; in terms of both number of operations and number of parameters. Further, due to memory limits, we found it only feasible to perform SGD with a small number of sequential frames per gradient step. In case of 3-D convolutions, this would make the temporal dimension considerably smaller during training than during synthesis; this would change the model’s input distribution between training and synthesis, which often leads to various temporal artifacts. Using 2-D convolutions in our flow $\\mathbf { f } _ { \\theta }$ with autoregressive priors, allows us to synthesize arbitrarily long sequences without introducing such artifacts. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            582,
+            326,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All our generated videos and qualitative results can be viewed at this website. In the generated videos, a border of blue represents the conditioning frame, while a border of red represents the generated frames. ",
+        "bbox": [
+            176,
+            613,
+            825,
+            655
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 VIDEO MODELLING WITH THE STOCHASTIC MOVEMENT DATASET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            674,
+            673,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We use VideoFlow to model the Stochastic Movement Dataset used in (Babaeizadeh et al., 2017). The first frame of every video consists of a shape placed near the center of a 64x64x3 resolution gray background with its type, size and color randomly sampled. The shape then randomly moves in one of eight directions with constant speed. (Babaeizadeh et al., 2017) show that conditioned on the first frame, a deterministic model averages out all eight possible directions in pixel space. Since the shape moves with a uniform speed, we should be able to model the position of the shape at the $( t + 1 ) ^ { t h }$ step using only the position of the shape at the $t ^ { t h }$ step. Using this insight, we extract random temporal patches of 2 frames from each video of 3 frames. We then use VideoFlow to maximize the loglikelihood of the second frame given the first, i.e the model looks back at just one frame. We observe that the bits-per-pixel on the holdout set reduces to a very low 0.04 bits-per-pixel for this model. On generating videos conditioned on the first frame, we observe that the model consistently predicts the future trajectory of the shape to be one of the eight random directions. We compare our model with two state-of-the-art stochastic video generation models SV2P and SAVP-VAE (Babaeizadeh et al., 2017; Lee et al., 2018) using their Tensor2Tensor implementation (Vaswani et al., 2018). We assess the quality of the generated videos using a real vs fake Amazon Mechanical Turk test. In the test, we inform the rater that a \"real\" trajectory is one in which the shape is consistent in color and congruent throughout the video. We show that VideoFlow outperforms the baselines in terms of fooling rate in Table 1 consistently generating plausible \"real\" trajectories at a greater rate. ",
+        "bbox": [
+            174,
+            702,
+            825,
+            922
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a70a8e6392d24bb4e096625d522326824168f40900514cb2bfe7e12e83736096.jpg",
+        "table_caption": [
+            "Table 2: Left: We report the average bits-per-pixel across 10 target frames with 3 conditioning frames for the BAIR action-free dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Bits-per-pixel</td></tr><tr><td>VideoFlow</td><td>1.87</td></tr><tr><td>SAVP-VAE</td><td>≤6.73</td></tr><tr><td>SV2P</td><td>≤6.78</td></tr></table>",
+        "bbox": [
+            232,
+            130,
+            441,
+            191
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/4f86fdecfe5c88f19ab3804eaa6bdd874d0e3a55b517fd8a901450bd247a62a3.jpg",
+        "image_caption": [
+            "Figure 3: We measure realism using a 2AFC test and diversity using mean pairwise cosine distance between generated samples in VGG perceptual space. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            580,
+            103,
+            761,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            301,
+            823,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 VIDEO MODELING WITH THE BAIR DATASET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            348,
+            532,
+            363
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We use the action-free version of the BAIR robot pushing dataset (Ebert et al., 2017) that contain videos of a Sawyer robotic arm with resolution 64x64. In the absence of actions, the task of video generation is completely unsupervised with multiple plausible trajectories due to the partial observability of the environment and stochasticity of the robot actions. We train the baseline models, SAVP-VAE, SV2P and SVG-LP to generate 10 target frames, conditioned on 3 input frames. We extract random temporal patches of 4 frames, and train VideoFlow to maximize the log-likelihood of the 4th frame given a context of 3 past frames. We, thus ensure that all models have seen a total of 13 frames during training. ",
+        "bbox": [
+            173,
+            376,
+            825,
+            487
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Bits-per-pixel: We estimated the variational bound of the bits-per-pixel on the test set, via importance sampling, from the posteriors for the SAVP-VAE and SV2P models. We find that VideoFlow outperforms these models on bits-per-pixel and report these values in Table 2. We attribute the high values of bits-per-pixel of the baselines to their optimization objective. They do not optimize the variational bound on the log-likelihood directly due to the presence of a $\\beta \\neq 1$ term in their objective and scheduled sampling (Bengio et al., 2015). ",
+        "bbox": [
+            173,
+            494,
+            825,
+            578
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a683d1e7f1ae30c014fcb1618147921f56b5ab1a13ce574e5e1b417cbbc090af.jpg",
+        "image_caption": [
+            "Figure 4: For a given set of conditioning frames on the BAIR action-free we sample 100 videos from each of the stochastic video generation models. We choose the video closest to the ground-truth on the basis of PSNR, SSIM and VGG perceptual metrics and report the best possible value for each of these metrics. All the models were trained using ten target frames but are tested to generate 27 frames. For all the reported metrics, higher is better. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            594,
+            751,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Accuracy of the best sample: The BAIR robot-pushing dataset is highly stochastic and the number of plausible futures are high. Each generated video can be super realistic, can represent a plausible future in theory but can be far from the single ground truth video perceptually. To partially overcome this, we follow the metrics proposed in prior work (Babaeizadeh et al., 2017; Lee et al., 2018; Denton & Fergus, 2018) to evaluate our model. For a given set of conditioning frames in the BAIR action-free test-set, we generate 100 videos from each of the stochastic models. We then compute the closest of these generated videos to the ground truth according to three different metrics, PSNR (Peak Signal to ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Noise Ratio), SSIM (Structural Similarity) (Wang et al., 2004) and cosine similarity using features obtained from a pretrained VGG network (Dosovitskiy & Brox, 2016; Johnson et al., 2016) and report our findings in Figure 4. This metric helps us understand if the true future lies in the set of all plausible futures according to the video model. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            159
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In prior work, (Lee et al., 2018; Babaeizadeh et al., 2017; Denton & Fergus, 2018) effectively tune the pixel-level variance as a hyperparameter and sample from a deterministic decoder. They obtain training stabiltiy and improve sample quality by removing pixel-level noise using this procedure. We can remove pixel-level noise in our VideoFlow model resulting in higher quality videos at the cost of diversity by sampling videos at a lower temperature, analogous to the procedure in (Kingma & Dhariwal, 2018). For a network trained with additive coupling layers, we can sample the $t ^ { t h }$ frame $x _ { t }$ from $P ( x _ { t } | x _ { < t } )$ with a temperature $T$ simply by scaling the standard deviation of the latent gaussian distribution $P ( \\boldsymbol { z } _ { t } | \\boldsymbol { z } _ { < t } )$ by a factor of $T$ . We report results with both a temperature of 1.0 and the optimal temperature tuned on the validation set using VGG similarity metrics in Figure 4. Additionally, we also applied low-temperature sampling to the latent gaussian priors of SV2P and SAVP-VAE and empirically found it to hurt performance. We report these results in Figure 12 ",
+        "bbox": [
+            174,
+            166,
+            825,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For SAVP-VAE, we notice that the hyperparameters that perform the best on these metrics are the ones that have disappearing arms. For completeness, we report these numbers as well as the numbers for the best performing SAVP models that do not have disappearing arms. Our model with optimal temperature performs better or as well as the SAVP-VAE and SVG-LP models on the VGG-based similarity metrics, which correlate well with human perception (Zhang et al., 2018) and SSIM. Our model with temperature $T = 1 . 0$ is also competent with state-of-the-art video generation models on these metrics. PSNR is explicitly a pixel-level metric, which the VAE models incorporate as part of its optimization objective. VideoFlow on the other-hand models the conditional probability of the joint distribution of frames, hence as expected it underperforms on PSNR. ",
+        "bbox": [
+            173,
+            325,
+            825,
+            452
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c96ecf49f00cd8a40874e3709c9498b9fc8b9cdb24e6e3baa904512d2a276bb.jpg",
+        "image_caption": [
+            "Figure 5: We display three different futures for two sets of conditioning frames (left and right) at $T = 0 . 6$ showcasing diversity in outcomes "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            467,
+            759,
+            622
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Diversity and quality in generated samples: For each set of conditioning frames in the test set, we generate 10 videos and compute the mean distance in VGG perceptual space across these 45 different pairs. We average this across the test-set for $T = 1 . 0$ and $T = 0 . 6$ and report these numbers in Figure 3. We also assess the quality of the generated videos at $T = 1 . 0$ and $T = 0 . 6$ , using a real vs fake Amazon Mechanical Turk test and report fooling rates. We observe that VideoFlow outperforms diversity values reported in prior work (Lee et al., 2018) while being competitive in the realism axis. We also find that VideoFlow at $T = 0 . 6$ has the highest fooling rate while being competent with state-of-the-art VAE models in diversity. ",
+        "bbox": [
+            173,
+            686,
+            825,
+            797
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On inspection of the generated videos, we find that at lower temperatures, the arm exhibits less random behaviour with the background objects remaining static and clear achieving higher realism scores. At higher temperatures, the motion of arm is much more stochastic, achieving high diversity scores with the background objects becoming much noisier leading to a drop in realism. ",
+        "bbox": [
+            174,
+            805,
+            823,
+            861
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fréchet Video Distance (FVD): We evaluate VideoFlow using the recently proposed Fréchet Video Distance (FVD) metric (Unterthiner et al., 2018), an adaptation of the Fréchet Inception Distance (FID) metric (Heusel et al., 2017) for video generation. (Unterthiner et al., 2018) report results with models trained on a total of 16 frames with 2 conditioning frames; while we train our VideoFlow model on a total of 13 frames with 3 conditioning frames, making our results not directly comparable to theirs. We evaluate FVD for both shorter and longer rollouts in Table 3. We show that, even in the settings that are disadvantageous to VideoFlow, where we compute the FVD on a total of 16 frames, when trained on just 13 frames, VideoFlow performs comparable to SAVP. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/a63db14401bf423cfbd1daaa34fc87fc0b48d1a57df43cba073401d1b19f362e.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\"># Frames Seen: Training</td></tr><tr><td>Conditioning</td><td>3</td><td>3</td><td>3</td><td>2</td></tr><tr><td>Total</td><td>13</td><td>13</td><td>13</td><td>16</td></tr><tr><td></td><td colspan=\"3\"># Frames: Evaluation</td><td></td></tr><tr><td>Ground truth</td><td>3</td><td>3</td><td>2</td><td></td></tr><tr><td>Total</td><td>13</td><td>16</td><td>16</td><td>26</td></tr><tr><td>Model</td><td colspan=\"3\">FVD</td><td></td></tr><tr><td>VideoFlow (T=0.8)</td><td>95±4</td><td>127±3</td><td>131±5</td><td>-</td></tr><tr><td>VideoFlow (T=1.0)</td><td>149±6</td><td>221±8</td><td>251±7</td><td>1</td></tr><tr><td>SAVP</td><td>-</td><td>-</td><td>-</td><td>116</td></tr><tr><td>SV2P</td><td>=</td><td>-</td><td>-</td><td>263</td></tr></table>",
+        "bbox": [
+            305,
+            99,
+            692,
+            289
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            367,
+            825,
+            424
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.3 LATENT SPACE INTERPOLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            440,
+            434,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "BAIR robot pushing dataset: We encode the first input frame and the last target frame into the latent space using our trained VideoFlow encoder and perform interpolations. We find that the motion of the arm is interpolated in a temporally cohesive fashion between the initial and final position. Further, we use the multi-level latent representation to interpolate representations at a particular level while keeping the representations at other levels fixed. We find that the bottom level interpolates the motion of background objects which are at a smaller scale while the top level interpolates the arm motion. ",
+        "bbox": [
+            174,
+            467,
+            826,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/aad55d52750b1b98a590db5a07d4d80b527972bc5a8c27149305eeda1edf2561.jpg",
+        "image_caption": [
+            "Table 3: Fréchet Video Distance:. We report the mean and standard deviation across 5 runs for 3 different frame settings. Results are not directly comparable across models due to the differences between the total number of frames seen during training and the number of conditioning frames. ",
+            "Figure 6: Left: We display interpolations between a) a small blue rectangle and a large yellow rectangle b) a small blue circle and a large yellow circle. Right: We display interpolations between the first input frame and the last target frame of two test videos in the BAIR robot pushing dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            582,
+            802,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Movement Dataset: We encode two different shapes with their type fixed but a different size and color into the latent space. We observe that the size of the shape gets smoothly interpolated. During training, we sample the colors of the shapes from a uniform discrete distribution which is reflected in our experiments. We observe that all the colors in the interpolated space lie in the set of colors in the training set. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            839
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.4 LONGER PREDICTIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            856,
+            372,
+            869
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We generate 100 frames into the future using our model trained on 13 frames with a temperature of 0.5 and display our results in Figure 7. On the top, even 100 frames into the future, the generated frames remain in the image manifold maintaining temporal consistency. In the presence of occlusions, the arm remains super-sharp but the background objects become noisier and blurrier. Our VideoFlow model has a bijection between the $\\mathbf { z } _ { t }$ and $\\mathbf { x } _ { t }$ meaning that the latent state $\\mathbf { z } _ { t }$ cannot store information other than that present in the frame $\\mathbf { x } _ { t }$ . This, in combination with the Markovian assumption in our latent dynamics means that the model can forget objects if they have been occluded for a few frames. In future work, we would address this by incorporating longer memory in our VideoFlow model; for example by parameterizing $N N _ { \\theta } ( )$ as a recurrent neural network in our autoregressive prior (eq. 8) or using more memory-efficient backpropagation algorithms for invertible neural networks (Gomez et al., 2017). ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/e59075b14cf3cea96145e3da800c6534f60d2202a1632b5473557eea428a6d49.jpg",
+        "image_caption": [
+            "Figure 7: Left: We generate 100 frames into the future with a temperature of 0.5. The top and bottom row correspond to generated videos in the absence and presence of occlusions respectively. Right: We use VideoFlow to detect the plausibility of a temporally inconsistent frame to occur in the immediate future. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            106,
+            696,
+            218
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            295,
+            825,
+            406
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.5 OUT-OF-SEQUENCE DETECTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            422,
+            434,
+            436
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We use our trained VideoFlow model, conditioned on 3 frames as explained in Section 5.2, to detect the plausibility of a temporally inconsistent frame to occur in the immediate future. We condition the model on the first three frames of a test-set video $X _ { < 4 }$ to obtain a distribution $P ( X _ { 4 } | X _ { < 4 } )$ over its 4th frame $X _ { 4 }$ . We then compute the likelihood of the $t ^ { \\mathrm { t h } }$ frame $X _ { t }$ of the same video to occur as the 4th time-step using this distribution. i.e, $\\mathcal { P } ( X _ { 4 } = X _ { t } \\vert X _ { < 4 } )$ for $t = 4 \\dots 1 3$ . We average the corresponding bits-per-pixel values across the test set and report our findings in Figure 7. We find that our model assigns a monotonically decreasing log-likelihood to frames that are more far out in the future and hence less likely to occur in the 4th time-step. ",
+        "bbox": [
+            174,
+            448,
+            825,
+            560
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "6 OPEN SOURCE CODE AND CHECKPOINTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            580,
+            542,
+            595
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We open-source the implementation of our code in the Tensor2Tensor codebase. We additionally open-source various components of our trained VideoFlow model, to evaluate log-likelihood, to generate frames and compute latent codes as reusable TFHub modules ",
+        "bbox": [
+            174,
+            611,
+            825,
+            652
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            672,
+            468,
+            689
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We describe a practically applicable architecture for flow-based video prediction models, inspired by the Glow model for image generation Kingma & Dhariwal (2018), which we call VideoFlow. We introduce a latent dynamical system model that predicts future values of the flow model’s latent state replacing the standard unconditional prior distribution. Our empirical results show that VideoFlow achieves results that are competitive with the state-of-the-art VAE models in stochastic video prediction. Finally, our model optimizes log-likelihood directly making it easy to evaluate while achieving faster synthesis compared to pixel-level autoregressive video models, making our model suitable for practical purposes. In future work, we plan to incorporate memory in VideoFlow to model arbitrary long-range dependencies and apply the model to challenging downstream tasks. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            829
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            845,
+            333,
+            857
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We would like to thank Ryan Sepassi and Lukasz Kaiser for their extensive help in using Tensor2Tensor, Oscar Täckström for finding a bug in our evaluation pipeline that improved results across all models, Ruben Villegas for providing code for the SVG-LP baseline and Mostafa Dehghani for providing feedback on a draft of the rebuttal. ",
+        "bbox": [
+            176,
+            867,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mohammad Babaeizadeh, Chelsea Finn, Dumitru Erhan, Roy H Campbell, and Sergey Levine. Stochastic variational video prediction. arXiv preprint arXiv:1710.11252, 2017. ",
+        "bbox": [
+            173,
+            126,
+            825,
+            155
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence prediction with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 1171–1179, 2015. ",
+        "bbox": [
+            174,
+            165,
+            825,
+            207
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Byron Boots, Arunkumar Byravan, and Dieter Fox. Learning predictive models of a depth camera & manipulator from raw execution traces. In International Conference on Robotics and Automation (ICRA), 2014. ",
+        "bbox": [
+            173,
+            218,
+            825,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. In Neural Information Processing Systems (NIPS), 2016. ",
+        "bbox": [
+            173,
+            270,
+            823,
+            300
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gustavo Deco and Wilfried Brauer. Higher order statistical decorrelation without information loss. Advances in Neural Information Processing Systems, pp. 247–254, 1995. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            339
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Emily Denton and Vighnesh Birodkar. Unsupervised learning of disentangled representations from video. arXiv preprint arXiv:1705.10915, 2017. ",
+        "bbox": [
+            173,
+            348,
+            823,
+            377
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Emily Denton and Rob Fergus. Stochastic video generation with a learned prior. arXiv preprint arXiv:1802.07687, 2018. ",
+        "bbox": [
+            173,
+            386,
+            825,
+            416
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, David Krueger, and Yoshua Bengio. Nice: non-linear independent components estimation. arXiv preprint arXiv:1410.8516, 2014. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            455
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using Real NVP. arXiv preprint arXiv:1605.08803, 2016. ",
+        "bbox": [
+            171,
+            464,
+            823,
+            493
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexey Dosovitskiy and Thomas Brox. Generating images with perceptual similarity metrics based on deep networks. In Advances in Neural Information Processing Systems, pp. 658–666, 2016. ",
+        "bbox": [
+            173,
+            503,
+            823,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Frederik Ebert, Chelsea Finn, Alex X Lee, and Sergey Levine. Self-supervised visual planning with temporal skip connections. arXiv preprint arXiv:1710.05268, 2017. ",
+        "bbox": [
+            171,
+            541,
+            823,
+            571
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn and Sergey Levine. Deep visual foresight for planning robot motion. In International Conference on Robotics and Automation (ICRA), 2017. ",
+        "bbox": [
+            176,
+            580,
+            823,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Ian Goodfellow, and Sergey Levine. Unsupervised learning for physical interaction through video prediction. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            174,
+            619,
+            823,
+            650
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Aidan N Gomez, Mengye Ren, Raquel Urtasun, and Roger B Grosse. The reversible residual network: Backpropagation without storing activations. In Advances in Neural Information Processing Systems, pp. 2211–2221, 2017. ",
+        "bbox": [
+            174,
+            659,
+            825,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in Neural Information Processing Systems, pp. 2672–2680, 2014. ",
+        "bbox": [
+            173,
+            712,
+            826,
+            756
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. arXiv preprint arXiv:1308.0850, 2013. ",
+        "bbox": [
+            171,
+            765,
+            825,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015. ",
+        "bbox": [
+            171,
+            803,
+            823,
+            833
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Martin Heusel, Hubert Ramsauer, Thomas Unterthiner, Bernhard Nessler, and Sepp Hochreiter. Gans trained by a two time-scale update rule converge to a local nash equilibrium. In Advances in neural information processing systems, pp. 6626–6637, 2017. ",
+        "bbox": [
+            173,
+            842,
+            823,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Long Short-Term Memory. Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Catalin Ionescu, Dragos Papava, Vlad Olaru, and Cristian Sminchisescu. Human3. 6m: Large scale datasets and predictive methods for 3d human sensing in natural environments. IEEE transactions on pattern analysis and machine intelligence, 36(7):1325–1339, 2014. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Johnson, Alexandre Alahi, and Li Fei-Fei. Perceptual losses for real-time style transfer and super-resolution. In European Conference on Computer Vision, pp. 694–711. Springer, 2016. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            185
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nal Kalchbrenner, Aäron van den Oord, Karen Simonyan, Ivo Danihelka, Oriol Vinyals, Alex Graves, and Koray Kavukcuoglu. Video pixel networks. International Conference on Machine Learning (ICML), 2017. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. Proceedings of the 2nd International Conference on Learning Representations, 2013. ",
+        "bbox": [
+            173,
+            246,
+            825,
+            275
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Durk P Kingma and Prafulla Dhariwal. Glow: Generative flow with invertible 1x1 convolutions. In Advances in Neural Information Processing Systems, pp. 10236–10245, 2018. ",
+        "bbox": [
+            174,
+            284,
+            821,
+            314
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoff Hinton. Imagenet classification with deep convolutional neural networks. In Advances in Neural Information Processing Systems 25, pp. 1106–1114, 2012. ",
+        "bbox": [
+            173,
+            323,
+            823,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex X Lee, Richard Zhang, Frederik Ebert, Pieter Abbeel, Chelsea Finn, and Sergey Levine. Stochastic adversarial video prediction. arXiv preprint arXiv:1804.01523, 2018. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            391
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yijun Li, Chen Fang, Jimei Yang, Zhaowen Wang, Xin Lu, and Ming-Hsuan Yang. Flow-grounded spatial-temporal video prediction from still images. In Proceedings of the European Conference on Computer Vision (ECCV), pp. 600–615, 2018. ",
+        "bbox": [
+            174,
+            400,
+            823,
+            443
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Raymond Yeh, Xiaoou Tang, Yiming Liu, and Aseem Agarwala. Video frame synthesis using deep voxel flow. International Conference on Computer Vision (ICCV), 2017. ",
+        "bbox": [
+            171,
+            452,
+            823,
+            482
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "William Lotter, Gabriel Kreiman, and David Cox. Deep predictive coding networks for video prediction and unsupervised learning. International Conference on Learning Representations (ICLR), 2017. ",
+        "bbox": [
+            173,
+            489,
+            825,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Michael Mathieu, Camille Couprie, and Yann LeCun. Deep multi-scale video prediction beyond mean square error. International Conference on Learning Representations (ICLR), 2016. ",
+        "bbox": [
+            171,
+            542,
+            823,
+            571
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            580,
+            825,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ryan Prenger, Rafael Valle, and Bryan Catanzaro. Waveglow: A flow-based generative network for speech synthesis. CoRR, abs/1811.00002, 2018. URL http://arxiv.org/abs/1811. 00002. ",
+        "bbox": [
+            174,
+            633,
+            826,
+            676
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Prajit Ramachandran, Tom Le Paine, Pooya Khorrami, Mohammad Babaeizadeh, Shiyu Chang, Yang Zhang, Mark A Hasegawa-Johnson, Roy H Campbell, and Thomas S Huang. Fast generation for convolutional autoregressive models. arXiv preprint arXiv:1704.06001, 2017. ",
+        "bbox": [
+            174,
+            685,
+            826,
+            729
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "MarcAurelio Ranzato, Arthur Szlam, Joan Bruna, Michael Mathieu, Ronan Collobert, and Sumit Chopra. Video (language) modeling: a baseline for generative models of natural videos. arXiv preprint arXiv:1412.6604, 2014. ",
+        "bbox": [
+            176,
+            738,
+            825,
+            781
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Scott Reed, Aäron van den Oord, Nal Kalchbrenner, Sergio Gómez Colmenarejo, Ziyu Wang, Dan Belov, and Nando de Freitas. Parallel multiscale autoregressive density estimation. arXiv preprint arXiv:1703.03664, 2017. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo Rezende and Shakir Mohamed. Variational inference with normalizing flows. In Proceedings of The 32nd International Conference on Machine Learning, pp. 1530–1538, 2015. ",
+        "bbox": [
+            169,
+            843,
+            825,
+            872
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Danilo J Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In Proceedings of the 31st International Conference on Machine Learning (ICML-14), pp. 1278–1286, 2014. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, Lucas Baker, Matthew Lai, Adrian Bolton, et al. Mastering the game of go without human knowledge. Nature, 550(7676):354, 2017. ",
+        "bbox": [
+            179,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Elman Mansimov, and Ruslan Salakhudinov. Unsupervised learning of video representations using lstms. In International Conference on Machine Learning, 2015. ",
+        "bbox": [
+            173,
+            154,
+            823,
+            183
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thomas Unterthiner, Sjoerd van Steenkiste, Karol Kurach, Raphael Marinier, Marcin Michalski, and Sylvain Gelly. Towards accurate generative models of video: A new metric & challenges, 2018. ",
+        "bbox": [
+            173,
+            190,
+            823,
+            219
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron Van Den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves, Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for raw audio. arXiv preprint arXiv:1609.03499, 2016. ",
+        "bbox": [
+            176,
+            227,
+            825,
+            270
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Lasse Espeholt, Oriol Vinyals, Alex Graves, et al. Conditional image generation with PixelCNN decoders. In Advances in Neural Information Processing Systems, pp. 4790–4798, 2016a. ",
+        "bbox": [
+            174,
+            279,
+            823,
+            320
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016b. ",
+        "bbox": [
+            171,
+            328,
+            825,
+            358
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, Oriol Vinyals, Lasse Espeholt, Alex Graves, and Koray Kavukcuoglu. Conditional image generation with PixelCNN decoders. arXiv preprint arXiv:1606.05328, 2016c. ",
+        "bbox": [
+            173,
+            364,
+            825,
+            409
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information Processing Systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            459
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Samy Bengio, Eugene Brevdo, Francois Chollet, Aidan N Gomez, Stephan Gouws, Llion Jones, Łukasz Kaiser, Nal Kalchbrenner, Niki Parmar, et al. Tensor2tensor for neural machine translation. arXiv preprint arXiv:1803.07416, 2018. ",
+        "bbox": [
+            174,
+            467,
+            825,
+            510
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Seunghoon Hong, Xunyu Lin, and Honglak Lee. Decomposing motion and content for natural video sequence prediction. arXiv preprint arXiv:1706.08033, 2017a. ",
+        "bbox": [
+            169,
+            517,
+            825,
+            546
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ruben Villegas, Jimei Yang, Yuliang Zou, Sungryull Sohn, Xunyu Lin, and Honglak Lee. Learning to generate long-term future via hierarchical prediction. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3560–3569. JMLR. org, 2017b. ",
+        "bbox": [
+            176,
+            554,
+            821,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carl Vondrick and Antonio Torralba. Generating the future with adversarial transformers. In Computer Vision and Pattern Recognition (CVPR), 2017. ",
+        "bbox": [
+            171,
+            604,
+            823,
+            633
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Carl Vondrick, Hamed Pirsiavash, and Antonio Torralba. Anticipating the future by watching unlabeled video. arXiv preprint arXiv:1504.08023, 2015. ",
+        "bbox": [
+            171,
+            642,
+            823,
+            671
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jacob Walker, Abhinav Gupta, and Martial Hebert. Dense optical flow prediction from a static image. In International Conference on Computer Vision (ICCV), 2015. ",
+        "bbox": [
+            171,
+            678,
+            825,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Alan C Bovik, Hamid R Sheikh, and Eero P Simoncelli. Image quality assessment: from error visibility to structural similarity. IEEE transactions on image processing, 2004. ",
+        "bbox": [
+            171,
+            715,
+            823,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jianwen Xie, Song-Chun Zhu, and Ying Nian Wu. Synthesizing dynamic patterns by spatial-temporal generative convnet. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), July 2017. ",
+        "bbox": [
+            173,
+            752,
+            825,
+            795
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jianwen Xie, Ruiqi Gao, Zilong Zheng, Song-Chun Zhu, and Ying Nian Wu. Learning dynamic generator model by alternating back-propagation through time. Proceedings of the AAAI Conference on Artificial Intelligence, 33:5498–5507, Jul 2019. ISSN 2159-5399. doi: 10.1609/aaai.v33i01. 33015498. URL http://dx.doi.org/10.1609/aaai.v33i01.33015498. ",
+        "bbox": [
+            173,
+            803,
+            825,
+            859
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jianwen Xie, Yang Lu, Ruiqi Gao, Song-Chun Zhu, and Ying Nian Wu. Cooperative training of descriptor and generator networks. IEEE Transactions on Pattern Analysis and Machine Intelligence, 42(1):27–45, Jan 2020. ISSN 1939-3539. doi: 10.1109/tpami.2018.2879081. URL http://dx.doi.org/10.1109/TPAMI.2018.2879081. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "SHI Xingjian, Zhourong Chen, Hao Wang, Dit-Yan Yeung, Wai-Kin Wong, and Wang-chun Woo. Convolutional lstm network: A machine learning approach for precipitation nowcasting. In Advances in Neural Information Processing Systems, 2015. ",
+        "bbox": [
+            178,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Tianfan Xue, Jiajun Wu, Katherine Bouman, and Bill Freeman. Visual dynamics: Probabilistic future frame synthesis via cross convolutional networks. In Advances in Neural Information Processing Systems, 2016. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang. The unreasonable effectiveness of deep features as a perceptual metric. arXiv preprint, 2018. ",
+        "bbox": [
+            174,
+            205,
+            823,
+            234
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A MOVING MNIST - QUALITATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            258,
+            611,
+            276
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1ae26f8204c28db75dd59209d1dcc0d6dd90682a57d18be970e0ad56f9a81cbb.jpg",
+        "image_caption": [
+            "Figure 8: We display ten frame rollouts conditioned on a single frame on the Moving MNIST dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            301,
+            813,
+            530
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Similar to the Stochastic Movement Dataset as described in Section 5.1, we extract random temporal patches of 2 frames on the Moving MNIST dataset (Srivastava et al., 2015). We train our VideoFlow model to maximize the log-likelihood of the second frame, given the first. Our rollouts over 10 frames capture realistic digit movement. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            638
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B HUMAN3.6M - QUALITATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            578,
+            676
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We model the Human3.6M dataset (Ionescu et al., 2014), by maximizing the log-likelihood of the 4th frame given the first three frames, in a random temporal patch of 4 frames. We observe that on this dataset, our model fails to capture reasonable human motion. We hope that by increasing model capacity and using more expressive priors, we can acheive better performance on this dataset in the future. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            761
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C DISCRETIZATION AND UNIFORM QUANTIZATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            781,
+            612,
+            797
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { D } = \\{ \\mathbf { x } ^ { ( i ) } \\} _ { i = 1 } ^ { N }$ be our dataset of i.i.d. observations of a random variable $\\mathbf { x }$ with an unknown true distribution $p ^ { * } ( \\mathbf { x } )$ . Our data consist of 8-bit videos, with each dimension rescaled to the domain $[ 0 , 2 5 5 / 2 5 6 ]$ . We add a small amount of uniform noise to the data, $\\mathbf { u } \\sim \\mathcal { U } ( 0 , 1 / 2 5 6 . )$ , matching its discretization level (Dinh et al., 2016; Kingma & Dhariwal, 2018). Let $q ( \\mathbf { x } )$ be the resulting empirical distribution corresponding to this scaling and addition of noise. Note that additive noise is required to prevent $q ( \\mathbf { x } )$ from having infinite densities at the datapoints, which can result in ill-behaved optimization of the log-likelihood; it also allows us to recast maximization of the log-likelihood as minimization of a KL divergence. ",
+        "bbox": [
+            174,
+            810,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0b91185728f0b682c869ab816f2e0acfa8d631d2f9f9401e63f3241c1bc2e2cc.jpg",
+        "image_caption": [
+            "Figure 9: We display ten frame rollouts conditioned on 3 frames on the Human3.6M dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            207,
+            108,
+            823,
+            328
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D RESIDUAL NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            400,
+            522,
+            416
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Here we’ll describe the architecture for the residual network N Nθ() that maps z(l)<t, z(>t to $( \\mu _ { t } ^ { ( l ) } , \\log \\sigma _ { t } ^ { ( l ) } )$ (Left: Figure 10). As shown in the left of Figure 10, let $\\mathbf { h } _ { t } ^ { ( > l ) }$ be the tensor representing $\\mathbf { z } _ { t } ^ { ( > l ) }$ after the split operation between levels in the multi-scale architecture. We apply a $1 \\times 1$ convolution over $\\mathbf { h } _ { t } ^ { ( > l ) }$ and concatenate this across channels to each laobtain $( ( W \\mathbf { h } _ { t } ^ { ( > l ) } ; \\mathbf { z } _ { t - 1 } ^ { ( l ) } ) , ( W \\mathbf { h } _ { t } ^ { ( > l ) } ; \\mathbf { z } _ { t - 2 } ^ { ( l ) } ) \\cdot \\cdot \\cdot ( W \\mathbf { h } _ { t } ^ { ( > l ) } ; \\mathbf { z } _ { t - n } ^ { ( l ) } ) )$ l independently. In this way, we. We transform these values into $( \\mu _ { t } ^ { ( l ) } , \\log \\sigma _ { t } ^ { ( l ) } )$ via a stack of residual blocks. We obtain a reduction in parameter count by sharing parameters across every 2 time-steps via 3-D convolutions in our residual blocks. ",
+        "bbox": [
+            173,
+            431,
+            825,
+            564
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "As shown in the right of Figure 10, each 3-D residual block consists of three layers. The first layer has a filter size of $2 \\mathrm { x } 3 \\mathrm { x } 3 $ with 512 output channels followed by a ReLU activation. The second layer has two $1 \\times 1 \\times 1$ convolutions via the Gated Activation Unit Van Den Oord et al. (2016); van den Oord et al. (2016a). The third layer has a filter size of $2 \\times 3 \\times 3$ with the number of output channels determined by the level. This block is replicated three times in parallel, with dilation rates 1, 2 and 4, after which the results of each block, in addition to the input of the residual block, are summed. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            655
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The first two layers are initialized using a Gaussian distribution and the last layer is initialized to zeroes. In that way, the residual network behaves as an identity network during initialization allowing stable optimization. After applying a sequence of residual blocks, we use the last temporal activation that should capture all context. We apply a final $1 \\times 1$ convolution to this activation to obtain $( \\Delta \\mathbf { z } _ { t } ^ { ( l ) } , \\log \\sigma _ { t } ^ { ( l ) } )$ . We then add $\\Delta \\mathbf { z } _ { t } ^ { ( l ) }$ to $\\mathbf { z } _ { t - 1 } ^ { ( l ) }$ to a temporal skip connection to output $\\mu _ { t } ^ { ( l ) }$ . This way, the network learns to predict the change in latent variables for a given level. We have provided visualizations of the network architecture in this website ",
+        "bbox": [
+            174,
+            661,
+            825,
+            762
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E ABLATION STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            785,
+            375,
+            801
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Through an ablation study, we experimentally evaluate the importance of the following components of our VideoFlow model: (1) the use of temporal skip connections, (2) the use Gated Activation Unit (GATU) instead of ReLUs in the residual network and (3) the use of dilations in $N N _ { \\pmb \\theta } ( \\pmb )$ in Section D ",
+        "bbox": [
+            174,
+            819,
+            825,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We start with a VideoFlow model with 256 channels in the coupling layer, 16 steps of flow and remove the components mentioned above to create our baseline. We use four different combinations of our components (described in Fig. 11) and keep the rest of the hyperparameters fixed across those combinations. For each combination we plot the mean bits-per-pixel on the holdout BAIR-action free dataset over $3 0 0 \\mathrm { K }$ training steps for both affine and additive coupling in Figure 11. For both the coupling layers, we observe that the VideoFlow model with all the components provide a significant boost in bits-per-pixel over our baseline. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/5c62f7722b1bac9a52aaa15acab7092dd9e004f373701395b671ba2a6b7d000b.jpg",
+        "image_caption": [
+            "Figure 10: Left: We predict a gaussian distribution over $\\mathbf { z } _ { t } ^ { ( l ) }$ via a 3-D Residual network conditioned on $\\mathbf { z } _ { < t } ^ { ( l ) }$ and $\\mathbf { z } _ { t } ^ { ( > l ) }$ . Right: Our 3-D residual network architecture is augmented with dilations and gated activation units improving performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            263,
+            98,
+            820,
+            392
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            484,
+            825,
+            527
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a3a293bf33b4240af6209c8aba92fa7184ba01c0c8b6a6a636b8cac0096329f.jpg",
+        "image_caption": [
+            "Figure 11: B: baseline, A: Temporal Skip Connection, C: Dilated Convolutions $^ +$ GATU, D: Dilation Convolutions $^ +$ Temporal Skip Connection, E: Dilation Convolutions $^ +$ Temporal Skip Connection $^ +$ GATU. We plot the holdout bits-per-pixel on the BAIR action-free dataset for different ablations of our VideoFlow model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            547,
+            754,
+            693
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We also note that other combinations—dilated convolutions $+ \\mathrm { G A T U }$ (C) and dilated convolutions $^ +$ the temporal skip connection —improve over the baseline. Finally, we experienced that increasing the receptive field in $N N _ { \\pmb \\theta } ( \\pmb )$ using dilated convolutions alone in the absence of the temporal skip connection or the GATU makes training highly unstable. ",
+        "bbox": [
+            173,
+            773,
+            825,
+            830
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "F EFFECT OF TEMPERATURE ON SAVP-VAE AND SV2P",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            655,
+            866
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We repeat our evaluations described in Figure 4 applying low temperature to the latent gaussian priors of SV2P and SAVP-VAE. We empirically find that decreasing temperature from 1.0 to 0.0 monotonically decreases the performance of the VAE models. Our insight is that the VideoFlow model gains by low-temperature sampling due to the following reason. At lower T, we obtain a tradeoff between a performance gain by noise removal from the background and a performance hit due to reduced stochasticity of the robot arm. On the other hand, the VAE models have a clear but slightly blurry background throughout from $T = 1 . 0$ to $T = 0 . 0$ . Reducing T in this case, solely reduces the stochasticity of the arm motion thus hurting performance. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bb63061df6ae8787f040753d2efd8153f7bb8335a1c7b8d8c4686ae0fbd1cb8.jpg",
+        "image_caption": [
+            "Figure 12: We repeat our evaluations described on the SV2P and SAVP-VAE model in Figure 4 using temperatures from 0.0 to 1.0 while sampling from the latent gaussian prior. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            754,
+            377
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            454,
+            825,
+            525
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "G LIKELIHOOD VS QUALITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            553,
+            426,
+            570
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/d738542bde975a00b392ea89c391243f5b3697e11cff5cdb08c216e539cfd2cc.jpg",
+        "image_caption": [
+            "Figure 13: We provide a comparison between training progression (measured in the mean bits-per-pixel objective on the test-set) and the quality of generated videos. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            608,
+            655,
+            790
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "We show correlation between training progression (measured in bits per pixel) and quality of the generated videos in Figure 13. We display the videos generated by conditioning on frames from the test set for three different values of bits-per-pixel on the test-set. As we approach lower bits-per-pixel, our VideoFlow model learns to model the structure of the arm with high quality as well as its motion resulting in high quality video. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "H VIDEOFLOW - BAIR HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            102,
+            560,
+            118
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "H.1 QUANTITATIVE - BITS-PER-PIXEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            450,
+            151
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "To report bits-per-pixel we use the following set of hyperparameters. We use a learning rate schedule of linear warmup for the first 10000 steps and apply a linear-decay schedule for the last 150000 steps. ",
+        "bbox": [
+            169,
+            165,
+            825,
+            194
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/887e7afd2b01320b3d4a3bdfb4b1e204a86fe6bcfac2a07d98dd20fd6a2217c4.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Flow levels</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Flow steps per level</td><td rowspan=1 colspan=1>24</td></tr><tr><td rowspan=1 colspan=1>Coupling</td><td rowspan=1 colspan=1>Affine</td></tr><tr><td rowspan=1 colspan=1>Number of coupling layer channels</td><td rowspan=1 colspan=1>512</td></tr><tr><td rowspan=1 colspan=1>Optimier</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>40</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>3e-4</td></tr><tr><td rowspan=1 colspan=1>Number of 3-D residual blocks</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>Numberof 3-D residualchannels</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Training steps</td><td rowspan=1 colspan=1>600K</td></tr></table>",
+        "bbox": [
+            341,
+            210,
+            655,
+            371
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "H.2 QUALITATIVE EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            392,
+            419,
+            407
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "For all qualitative experiments and quantitative comparisons with the baselines, we used the following sets of hyperparameters. ",
+        "bbox": [
+            174,
+            420,
+            823,
+            449
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/e1df5f83cf4b56c7fd68944789e4f0156c3f0e68fff6d4a12362c545aefcf253.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Hyperparameter</td><td rowspan=1 colspan=1>Value</td></tr><tr><td rowspan=1 colspan=1>Flowlevels</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=1 colspan=1>Flow steps per level</td><td rowspan=1 colspan=1>24</td></tr><tr><td rowspan=1 colspan=1>Coupling</td><td rowspan=1 colspan=1>Additive</td></tr><tr><td rowspan=1 colspan=1>Number of coupling layer channels</td><td rowspan=1 colspan=1>392</td></tr><tr><td rowspan=1 colspan=1>Optimier</td><td rowspan=1 colspan=1>Adam</td></tr><tr><td rowspan=1 colspan=1>Batch size</td><td rowspan=1 colspan=1>40</td></tr><tr><td rowspan=1 colspan=1>Learning rate</td><td rowspan=1 colspan=1>3e-4</td></tr><tr><td rowspan=1 colspan=1>Numberof 3-D residualblocks</td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>Number of 3-D residual channels</td><td rowspan=1 colspan=1>256</td></tr><tr><td rowspan=1 colspan=1>Training steps</td><td rowspan=1 colspan=1>500K</td></tr></table>",
+        "bbox": [
+            334,
+            465,
+            663,
+            626
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "I HYPERPARAMETER GRID FOR THE BASELINE VIDEO MODELS.",
+        "text_level": 1,
+        "bbox": [
+            171,
+            650,
+            712,
+            665
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We train all our baseline models for 300K steps using the Adam optimizer. Our models were tuned using the maximum VGG cosine similarity metric with the ground-truth across 100 decodes. ",
+        "bbox": [
+            173,
+            684,
+            823,
+            712
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "SAVP-VAE and SV2P: We use three values of latent loss multiplier 1e-3, 1e-4 and 1e-5. For the SAVP-VAE model, we additionally apply linear decay on the learning rate for the last 100K steps. SAVP-GAN: We tune the gan loss multiplier and the learning rate on a logscale from 1e-2 to 1e-4 and 1e-3 to 1e-5 respectively. ",
+        "bbox": [
+            169,
+            718,
+            826,
+            775
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "J CORRELATION BETWEEN VGG PERCEPTUAL SIMILARITY AND BITS-PER-PIXEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            800,
+            722,
+            834
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "We plot correlation between cosine similarity using a pretrained VGG network and bits-per-pixel using our trained VideoFlow model. We compare $\\bar { \\mathcal { P } } ( X _ { 4 } ^ { - } = X _ { t } | X _ { < 4 } )$ as done in Section 5.5 and the VGG cosine similarity between $X _ { 4 }$ and $X _ { t }$ for $t = 4 \\dots 1 3$ . We report our results for every video in the test set in Figure 15. We notice a weak correlation between VGG perceptual metrics and bits-per-pixel with a correlation factor of $- 0 . 5 1$ . ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/92700e01fc04c693d4825d020ac49caa2609059e9174954bcaf7e0480c1bdb49.jpg",
+        "image_caption": [
+            "Figure 14: We compare $\\mathcal { P } ( X _ { 4 } = X _ { t } \\vert X _ { < 4 } )$ and VGG cosine similarity between $X _ { 4 }$ and $X _ { t }$ for $t = 4 \\dots 1 3$ "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            343,
+            112,
+            630,
+            289
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "K VIDEOFLOW: LOW PARAMETER REGIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            340,
+            547,
+            356
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We repeated our evaluations described in Figure 4, with a smaller version of our VideoFlow model with $4 \\mathbf { x }$ parameter reduction. Our model remains competetive with SVG-LP on the VGG perceptual metrics. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            412
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/c076a1a61ad38e20102a452d42cf85215f6e6f8034a16c569e2e4227bb7e7cc0.jpg",
+        "image_caption": [
+            "Figure 15: We repeat our evaluations described in Figure 4 with a smaller version of our VideoFlow model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            428,
+            656,
+            597
+        ],
+        "page_idx": 17
+    }
+]