Add files using upload-large-folder tool

parse/train/9CPc4EIr2t1/9CPc4EIr2t1.md

@@ -0,0 +1,294 @@
+# Stable Neural ODE with Lyapunov-Stable Equilibrium Points for Defending Against Adversarial Attacks
+
+# Qiyu Kang∗
+
+Continental-NTU Corporate Lab Nanyang Technological University 50 Nanyang Avenue, 639798, Singapore kang0080@e.ntu.edu.sg
+
+Yang Song∗ School of Electrical and Electronic Engineering Nanyang Technological University 50 Nanyang Avenue, 639798, Singapore songy@ntu.edu.sg
+
+# Qinxu Ding
+
+School of Business   
+Singapore University of Social Sciences   
+463 Clementi Road, 599494, Singapore qinxuding@suss.edu.sg
+
+Wee Peng Tay School of Electrical and Electronic Engineering Nanyang Technological University 50 Nanyang Avenue, 639798, Singapore wptay@ntu.edu.sg
+
+# Abstract
+
+Deep neural networks (DNNs) are well-known to be vulnerable to adversarial attacks, where malicious human-imperceptible perturbations are included in the input to the deep network to fool it into making a wrong classification. Recent studies have demonstrated that neural Ordinary Differential Equations (ODEs) are intrinsically more robust against adversarial attacks compared to vanilla DNNs. In this work, we propose a stable neural ODE with Lyapunov-stable equilibrium points for defending against adversarial attacks (SODEF). By ensuring that the equilibrium points of the ODE solution used as part of SODEF is Lyapunov-stable, the ODE solution for an input with a small perturbation converges to the same solution as the unperturbed input. We provide theoretical results that give insights into the stability of SODEF as well as the choice of regularizers to ensure its stability. Our analysis suggests that our proposed regularizers force the extracted feature points to be within a neighborhood of the Lyapunov-stable equilibrium points of the ODE. SODEF is compatible with many defense methods and can be applied to any neural network’s final regressor layer to enhance its stability against adversarial attacks.
+
+# 1 Introduction
+
+Although deep learning has found successful applications in many tasks such as image classification [1, 2], speech recognition [3], and natural language processing [4], the vulnerability of deep learning to adversarial attacks (e.g., see [5]) has limited its real-world applications due to performance and safety concerns in critical applications. Inputs corrupted with human-imperceptible perturbations can easily fool many vanilla deep neural networks (DNNs) into mis-classifying them and thus significantly impact their performance.
+
+Recent studies [6–8] have applied neural Ordinary Differential Equations (ODEs) [9] to defend against adversarial attacks. Some works like [6] have revealed interesting intrinsic properties of
+
+ODEs that make them more stable than conventional convolutional neural networks (CNNs). The paper [6] proposes a time-invariant steady neural ODE (TisODE) using the property that the integral curves from a ODE solution starting from different initial points (inputs) do not intersect and always preserve uniqueness in the solution function space. However, this does not guarantee that small perturbations of the initial point lead to small perturbations of the integral curve output at a later time $T$ . The authors thus proposed a regularizer to limit the evolution of the curves by forcing the integrand to be close to zero. However, neither the non-intersecting property nor the steady-state constraint used in TisODE can guarantee robustness against input perturbations since these constraints do not ensure that the inputs are within a neighborhood of Lyapunov-stable equilibrium points. An example is an ODE that serves as an identity mapping is not robust to input perturbations but satisfies all the constraints proposed in [6].
+
+In this paper, our objective is to design a neural ODE such that the features extracted are within a neighborhood of the Lyapunov-stable equilibrium points of the ODE. We first develop a diversity promoting technique applied in the final fully connected (FC) layer to improve the ODE’s stability and analyze the reasons why. We then propose a stable neural ODE with Lyapunov-stable equilibrium points to eliminate the effects of perturbations in the input. From linear control theory [10], a linear time-invariant system $\mathrm { d } { \mathbf { z } ( t ) } / \mathrm { d } t = { \mathbf { A } } { \mathbf { z } ( t ) }$ , where $\mathbf { A }$ is a constant matrix, is exponentially stable if all eigenvalues of $\mathbf { A }$ have negative real parts. Specifically, we propose to force the Jacobian matrix of the ODE used in the neural ODE to have eigenvalues with negative real parts. Instead of directly imposing constraints on the eigenvalues of the matrix, which lead to high computational complexity when the Jacobian matrix is large, we instead add constraints to the matrix elements to implicitly force the real parts of its eigenvalues to be negative.
+
+Our main contributions are summarized as follows:
+
+1. Based on the concept of Lyapunov-stable equilibrium points, we propose a simple yet effective technique to improve the robustness of neural ODE networks by fixing the final FC layer to be a matrix whose rows have unit norm and such that the maximum cosine similarity between any two rows is minimized. Such a FC layer can be constructed off-line.   
+2. We propose a stable neural ODE for deFending against adversarial attacks (SODEF) to suppress the input perturbations. We derive an optimization formulation for SODEF to force the extracted feature points to be within a neighborhood of the Lyapunov-stable equilibrium points of the SODEF ODE. We provide sufficient conditions for learning a robust feature representation under SODEF.   
+3. We test SODEF on several widely used datasets MNIST [11], CIFAR-10 and CIFAR-100 [12] under well-known adversarial attacks. We demonstrate that SODEF is robust against adversarial white-box attacks with improvement in classification accuracy of adversarial examples under PGD attack [13] of up to $4 4 . 0 2 \%$ , $5 2 . 5 4 \%$ and $1 8 . 9 1 \%$ percentage points compared to another current state-of-the-art neural ODE network TisODE [6] on MNIST, CIFAR-10 and CIFAR-100, respectively. Similar improvements in classification accuracy of adversarial examples of up to $\bar { 4 3 . 6 9 \% }$ , $5 2 . 3 8 \%$ and $\mathrm { \bar { 1 8 . 9 9 \% } }$ percentage points compared to ODE net [9] are also obtained.
+
+The rest of this paper is organized as follows. We provide essential preliminaries on neural ODE and its stability analysis in Section 2. In Section 3, we present SODEF model architecture and its training method. We show how to maximize the distance between stable equilibrium points of neural ODEs. We propose an optimization and present theoretical results on its stability properties. We summarize experimental results in Section 4 and conclude the paper in Section 5. The proofs for all lemmas and theorems proposed in this paper are given in the supplementary material. We also refer interested readers to the supplementary material for a more detailed account of related works [14–16, 6] and some popular adversarial attacks [17, 13] that are used to verify the robustness of our proposed SODEF. In the paper, we use lowercase boldface characters like $\mathbf { z }$ to denote vectors in $\mathbb { R } ^ { n }$ , capital boldface characters like $\mathbf { A }$ to denote matrices in $\mathbb { R } ^ { n \times n }$ , and normal characters like $z$ to denote scalars except that the notation $( x , y )$ are normal characters reserved to denote the input and label pairs. A vector $\mathbf { z } \in \mathbb { R } ^ { n }$ is represented as $( \mathbf { z } ^ { ( 1 ) } , \mathbf { z } ^ { ( 2 ) } , \ldots , \mathbf { z } ^ { ( n ) } )$ . The $( i , j )$ -th element of a matrix $\mathbf { A }$ is $\mathbf { A } _ { i j }$ or $[ \mathbf { A } ] _ { i j }$ . The Jacobian matrix of a function $f : \mathbb { R } ^ { n } \mapsto \mathbb { R } ^ { n }$ evaluated at $\mathbf { z }$ is denoted as $\nabla f ( \mathbf { z } )$ The set of functions $\mathbb { R } ^ { n } \mapsto \mathbb { R } ^ { n }$ with continuous first derivatives is denoted as $C ^ { 1 } ( \mathbb { R } ^ { n } , \mathbb { R } ^ { n } )$ .
+
+# 2 Preliminaries: Neural ODE and Stability
+
+In a neural ODE layer, the relation between the layer input ${ \bf z } ( 0 )$ and output ${ \mathbf z } ( T )$ is described as the following differential equation:
+
+$$
+\frac { \mathrm { d } \mathbf { z } ( t ) } { \mathrm { d } t } = f _ { \pmb { \theta } } ( \mathbf { z } ( t ) , t )
+$$
+
+where $f _ { \pmb \theta } : \mathbb { R } ^ { n } \times [ 0 , \infty ) \mapsto \mathbb { R } ^ { n }$ denotes the non-linear trainable layers that are parameterized by weights $\pmb { \theta }$ and $\mathbf { z } : [ 0 , \infty ) \mapsto \mathbb { R } ^ { n }$ represents the $n$ -dimensional state of the neural ODE. Neural ODEs are the continuous analog of residual networks where the hidden layers of residual networks can be regarded as discrete-time difference equations ${ \bf z } ( t + 1 ) = { \bf z } ( t ) + { f _ { \theta } } ( { \bf z } ( t ) , t )$ . In this work, for simplicity, we only consider the time-invariant (autonomous) case $f _ { \pmb \theta } ( \mathbf { z } ( t ) , t ) = f _ { \pmb \theta } ( \mathbf { z } ( t ) )$ , where the dynamical system does not explicitly depend on $t$ . For such non-linear dynamical systems, the following theorem shows that under mild conditions, its behaviour can be studied via linearization near special points called hyperbolic equilibrium points.
+
+Theorem 1 (Hartman–Grobman Theorem [18]). Consider a system evolving in time with state $\mathbf { z } ( t ) \in \mathbb { R } ^ { n }$ that satisfies the differential equation $\frac { \mathrm { d } { \bf z } ( t ) } { \mathrm { d } t } = f ( { \bf z } ( t ) )$ for some $f \in C ^ { 1 } ( \mathbb { R } ^ { n } , \mathbb { R } ^ { n } ) ;$ , $f ( \mathbf { z } ) = ( f ^ { ( 1 ) } ( \mathbf { z } ) , \ldots , f ^ { ( n ) } ( \mathbf { z } ) )$ . Suppose the map has a hyperbolic equilibrium state $\mathbf { z } ^ { \ast } \in \mathbb { R } ^ { n }$ , i.e., $f ( { \bf z } ^ { * } ) = 0$ and the Jacobian matrix  with real part equal to zer $\nabla f = [ \partial f ^ { ( i ) } / \partial \mathbf { z } ^ { ( j ) } ] _ { i , j = 1 } ^ { n }$ of hb $f$ evalurhood at of $\textbf { z } = \textbf { z } ^ { * }$ has nolibrium $N _ { \mathbf { z } ^ { * } }$ point $\mathbf { z } ^ { \ast }$ and a homeomorphism $g : N _ { \mathbf { z } ^ { * } } \mapsto \mathbb { R } ^ { n }$ , such that $g ( \mathbf { z } ^ { * } ) = 0$ and in the neighbourhood $N _ { \mathbf { z } ^ { * } }$ , the flow of $\frac { \mathrm { d } { \bf z } ( t ) } { \mathrm { d } t } = f ( { \bf z } ( t ) )$ is topologically conjugate by the continuous map $\bar { \mathbf { z } } ( t ) = g ( \mathbf { z } ( t ) )$ to the flow of its linearization $\frac { \mathrm { d } \bar { \mathbf { z } } ( t ) } { \mathrm { d } t } = \nabla f ( \mathbf { z } ^ { * } ) \cdot \bar { \mathbf { z } } ( t ) .$
+
+The theorem states that when the Jacobian matrix at the zeros of $f$ has no eigenvalue with zero real part, the behaviour of the original dynamical system can be studied using the simpler linearization of the system around those zeros. We next review some definitions and theorems from linear control theory [10].
+
+Definition 1 (Lyapunov Stability [10]). The linear time-invariant system $\frac { \mathrm { d } \bar { \mathbf { z } } ( t ) } { \mathrm { d } t } = \mathbf { A } \bar { \mathbf { z } } ( t )$ with constant matrix A is marginally stable or stable in the sense of Lyapunov if every finite initial state $\bar { \mathbf { z } } ( 0 )$ excites a bounded response. It is asymptotically stable if every finite initial state excites $a$ bounded response, which, in addition, approaches 0 as $t \to \infty$ .
+
+Theorem 2 (Lyapunov Stability Theorem [10]). a) The equation $\frac { \mathrm { d } \bar { \mathbf { z } } ( t ) } { \mathrm { d } t } = \mathbf { A } \bar { \mathbf { z } } ( t ) )$ is marginally stable if and only if all eigenvalues of A have zero or negative real parts and those with zero real parts are simple roots of the minimal polynomial of A. $^ b$ ) The equation $\frac { \mathrm { d } \bar { \mathbf { z } } ( t ) } { \mathrm { d } t } = \mathbf { A } \bar { \mathbf { z } } ( t )$ is asymptotically stable if and only if all eigenvalues of A have negative real parts.
+
+In Theorem 1, we say that a hyperbolic equilibrium point is Lyapunov-stable if all eigenvalues of the Jacobian matrix evaluated at it have negative real parts. From Theorems 1 and 2, we see that a small perturbation around the Lyapunov-stable equilibrium point ${ \bf z } ( 0 )$ leads to $\tilde { \mathbf { z } } ( t ) \to \mathbf { z } ( 0 )$ as $t \to \infty$ , i.e., $\exists \delta > 0$ such that for all $\tilde { \mathbf { z } } ( 0 )$ with $\lVert { \mathbf z } ( 0 ) \dot { - } \tilde { { \mathbf z } } ( 0 ) \rVert _ { 2 } \dot { < } \delta$ , we have $\| \widetilde { \mathbf { z } } ( t ) - \mathbf { z } ( 0 ) \| _ { 2 } \to \dot { 0 }$ as $t \to \infty$ , where $\tilde { \mathbf { z } } ( t )$ is the ODE solution for the perturbed input $\tilde { \mathbf { z } } ( 0 )$ . In the context of neural network adversarial attacks, if the malicious perturbations around the ODE input ${ \bf z } ( 0 )$ is small, then the output ${ \mathbf z } ( T )$ for large enough $T$ will not be affected significantly by the perturbation. Consequently, the succeeding network layers after the neural ODE layer can still perform well without being affected by the input perturbation. The perturbation weakening phenomenon around Lyapunov-stable equilibrium points works like a noise filter and acts as a defense against adversarial attacks.
+
+We require the following definition and result in our stability analysis.
+
+Definition 2 (Strictly diagonally dominant [19]). Let $\mathbf { A } \in \mathbb { C } ^ { n \times n }$ . We say that A is strictly diagonally dominant if $\begin{array} { r } { \left| { { { \mathbf { A } } _ { i i } } } \right| > \sum _ { j \neq i } \left| { { { \mathbf { A } } _ { i j } } } \right| } \end{array}$ for all $i = 1 , . . . , n$ .
+
+Theorem 3 (Levy–Desplanques theorem [19]). If $\mathbf { A } \in \mathbb { C } ^ { n \times n }$ is strictly diagonally dominant and if every main diagonal entry of A is real and negative, then $A$ is non-singular and every eigenvalue of A has negative real part.
+
+![](images/96641a4aad1ec2c9f3138777e3d67fc9ff9849146d1c1b15becd36b84d50c353.jpg)  
+Fig. 1: SODEF model architecture.
+
+Lemma 1. Given $k$ distinct points $\mathbf { z } _ { i } \in \mathbb { R } ^ { n }$ and matrices $\mathbf { A } _ { i } \in \mathbb { R } ^ { n \times n }$ , $i = 1 , . . . , k$ , there exists a function $f \in C ^ { 1 } ( \mathbb { R } ^ { n } , \mathbb { R } ^ { n } )$ such that $f ( \mathbf { z } _ { i } ) = 0$ and $\nabla f _ { \pmb { \theta } } ( \mathbf { z } _ { i } ) = \mathbf { A } _ { i }$ .
+
+# 3 SODEF Architecture
+
+We consider a classification problem with $L$ classes. The proposed SODEF model architecture is shown in Fig. 1. The input $x \in X$ (e.g., an image) is first passed through a feature extractor $h _ { \phi } : X \mapsto \mathbb { R } ^ { n }$ to obtain an embedding feature representation ${ \bf z } ( 0 )$ . A neural ODE layer $f _ { \theta }$ follows as a nonlinear feature mapping to stabilize the feature representation output ${ \bf z } ( 0 )$ from $h _ { \phi }$ . The final FC layer $\mathbf { V }$ serves as a linear mapping to generate a prediction vector based on the output $\mathbf { \dot { z } } ( T )$ of the neural ODE layer. The parameters $\phi , \theta$ and $\mathbf { V }$ are parameterized weights for the feature extractor, neural ODE layer and FC layer, respectively.
+
+We provide motivation and design guidance for the FC layer V in Section 3.1, which attempts to separate Lyapunov-stable equilibrium points implicitly by maximizing the similarity distance between feature representations corresponding to the $L$ different classes. Experimental results demonstrate the advantages of our diversity promoting FC layer in Section 3.1 with comparisons to traditional neural ODEs without diversity promoting.
+
+However, the embedded features after using diversity promoting are not guaranteed to locate near the Lyapunov-stable equilibrium points. In Section 3.2, we formulate an optimization problem to force embedding features to locate near the Lyapunov-stable equilibrium points. We introduce optimization constraints to force the Jacobian matrix of the ODE in our neural ODE layer to have eigenvalues with negative real parts at the Lyapunov-stable equilibrium points. Instead of directly imposing constraints on the eigenvalue of the matrix, which may be computationally complex especially when the matrix is large, we add constraints to the matrix elements instead.
+
+# 3.1 Maximizing the Distance between Lyapunov-Stable Equilibrium Points
+
+From Section 2, we observe that points in a small neighbourhood of a Lyapunov-stable equilibrium point is robust against adversarial perturbations. We call this neighborhood a stable neighborhood. However Lyapunov-stable equilibrium points for different classes may very well locate near each other and therefore each stable neighborhood may be very small, leading to poor adversarial defense. In this section, we propose to add a FC layer after the neural ODE layer given by (1) to avoid this scenario. The purpose of the FC layer is to map the output of the neural ODE layer to a feature vector $\mathbf { v } _ { l }$ if the input $x$ belongs to the class $l = 1 , \ldots , L$ . We design the FC layer so that the cosine similarities between different $\mathbf { v } _ { l }$ ’s are minimized.
+
+Lemma 2. Given a set of $k$ unit vectors $\mathbf { v } _ { 1 } , \ldots , \mathbf { v } _ { k }$ in $\mathbb { R } ^ { n }$ , where $n \geq k$ , let $a ( \mathbf { v } _ { 1 } , \ldots , \mathbf { v } _ { k } ) =$ $\mathrm { m a x } _ { i \neq j } { \mathbf { \Delta v } _ { i } ^ { \mathsf { T } } } { \mathbf { v } _ { j } }$ . Then $\operatorname* { m i n } a ( \mathbf { v } _ { 1 } , . . . , \mathbf { v } _ { k } ) = 1 / ( 1 - k )$ , where the minimum is taken over all possible sets of $k$ unit vectors $\mathbf { v } _ { 1 } , \ldots , \mathbf { v } _ { k }$ .
+
+Corollary 1. Consider a $k \times k$ matrix $\mathbf { B } = [ b _ { i j } ] _ { i , j = 1 } ^ { k }$ with $b _ { i i } = 1$ and $b _ { i j } = 1 / ( 1 - k )$ , $\forall i \ne j$ Let the eigen decomposition of $\mathbf { B }$ be $\mathbf { B } = \mathbf { U } \pmb { \Sigma } \bar { \mathbf { U } } ^ { \dag }$ . For any $n \geq k$ and $i = 1 , \ldots , k$ , let $\mathbf { v } _ { i }$ be the $i$ -th column of $\mathbf { Q } \mathbf { \Sigma } ^ { \mathrm { { X } ^ { 1 / 2 } \bar { U } ^ { \top } } }$ , where $\mathbf { Q }$ is any $n \times k$ matrix such that $\mathbf { Q } ^ { \intercal } \mathbf { Q } = \mathbf { I } _ { k }$ . Then, $a ( \mathbf { v } _ { 1 } , \ldots , \mathbf { v } _ { k } ) = \operatorname* { m a x } _ { i \neq j } \mathbf { v } _ { i } ^ { \mathsf { T } } \mathbf { v } _ { j } = { 1 } / ( 1 - k )$ .
+
+Corollary 1 suggests a diversity promoting scheme to maximally separate the equilibrium points of the neural ODE layer. The FC layer is represented by an $n \times L$ matrix $\mathbf { V } = \left[ \mathbf { v } _ { 1 } , \ldots , \mathbf { v } _ { L } \right]$ , where $n$ is the dimension of ${ \mathbf z } ( T )$ , the output from the neural ODE layer. If ${ \mathbf z } ( T )$ is generated from an input from class $l$ , it is mapped to $\mathbf { v } _ { l }$ . By minimizing the maximum cosine similarity $a ( \mathbf { v } _ { 1 } , \ldots , \mathbf { v } _ { k } ) = \operatorname* { m a x } _ { i \neq j } \mathbf { v } _ { i } ^ { \mathsf { T } } \mathbf { v } _ { j }$ between the representations from two different classes, we ensure that the output of SODEF is robust to perturbations in the input. Corollary 1 provides a way to choose the FC layer weights $\mathbf { V }$ .
+
+To validate our observations, we conduct experiments to compare the robustness of ODE net [9] and TisODE [6] with and without our proposed FC layer V, on two standard datasets: MNIST [2] and CIFAR10 [12] 2. On the MNIST dataset, all models consist of four convolutional layers and one fully-connected layer. On the CIFAR10 dataset, the networks are similar to those for MNIST except the down-sampling network is a stack of 2 ResNet blocks. In practice, the neural ODE can be solved with different numerical solvers such as the Euler method and the Runge-Kutta methods [9]. Here, we use Runge-Kutta of order 5 in our experiments. Our implementation builds on the open-source neural ODE codes.3 During training, no Gaussian noise or adversarial examples are augmented into the training set. We test the performance of our model in defending against white-box attacks FGSM [17] and PGD [13] . The parameters for different attack methods used in this paper are given in the supplementary material. From Tables 1 and 2, we observe that for both datasets, our fixed FC layer improves each network’s defense ability by a significant margin. We visualize the features before the final FC layer using t-SNE [20] in Figs. 2 and 3. We observe that with the FC layer, the features for different classes are well separated even under attacks.
+
+Table 1: Classification accuracy $( \% )$ on adversarial MNIST examples, where the superscript + indicates the last FC layer is fixed to be $\mathbf { V }$ .   
+
+<table><tr><td>Attack</td><td>Para.</td><td>ODE</td><td>ODE+</td><td>TisODE</td><td>TisODE+</td></tr><tr><td>None</td><td>-</td><td>99.6</td><td>99.7</td><td>99.5</td><td>99.7</td></tr><tr><td>FGSM</td><td>∈ = 0.3</td><td>31.4</td><td>52.8</td><td>45.9</td><td>63.5</td></tr><tr><td>PGD</td><td>∈=0.3</td><td>0.29</td><td>0.30</td><td>0.4</td><td>20.20</td></tr></table>
+
+Table 2: Classification accuracy $( \% )$ on adversarial CIFAR10 examples, where the superscript + indicates the last FC layer is fixed to be $\mathbf { V }$ .   
+
+<table><tr><td>Attack</td><td>Para.</td><td>ODE ODE+</td><td>TisODE</td><td>TisODE+</td></tr><tr><td>None</td><td>-</td><td>87.0 85.0</td><td>87.4</td><td>81.8</td></tr><tr><td>FGSM</td><td>∈ = 0.1</td><td>12.9 47.6</td><td>13.1</td><td>41.9</td></tr><tr><td>PGD</td><td>∈=0.1</td><td>7.8 14.7</td><td>7.4</td><td>16.2</td></tr></table>
+
+![](images/2298e75b6e25d3394e76c905205ab4b066d9a6a5a3e690669fcd410610b0c475.jpg)  
+Fig. 2: t-SNE visualization results on the features before the final FC layer. The input is the test set of MNIST. Left: trained with TisODE, middle: TisODE using a randomly chosen orthogonal matrix as the final FC, right: TisODE using proposed $\mathbf { V }$ as the final FC.
+
+# 3.2 Objective Formulation and Stability
+
+In this subsection, we formulate an optimization framework for SODEF to force output features to locate within the stable neighborhood of Lyapunov-stable equilibrium points. We make the following assumption.
+
+Assumption 1. The input x takes values in a compact metric space $X$ and has probability distribution $\mu$ . The feature extractor $h _ { \phi }$ is injective and continuous.
+
+![](images/7a95cfded3451c7f092fca178fd0f289e9f1e03180a9b9200b577ccb2fbf9ae9.jpg)  
+Fig. 3: t-SNE visualization results on the features before the final FC layer. The input is the adversarial examples of the test set of MNIST generated using FGSM method at $\epsilon = 0 . 3$ . Left: trained with TisODE, middle: TisODE using a randomly chosen orthogonal matrix as the final FC, right: TisODE using proposed $\mathbf { V }$ as the final FC.
+
+The above assumption is satisfied if the input $x$ (e.g., an image) resides in a bounded and closed set of a Euclidean space. We denote the pushforward measure (still a probability distribution) of $\mu$ under the continuous feature extractor mapping $h _ { \phi }$ as $\nu _ { \phi } = \mu \circ h _ { \phi } ^ { - 1 }$ , where $\circ$ denotes function composition. The conditional probability distribution for the embedding of each class $l \in \{ 1 , . . . , L \}$ has compact support $E _ { l } \subset \mathbb { R } ^ { n }$ since $E _ { l }$ is closed and $h _ { \phi } ( X )$ is bounded in $\mathbb { R } ^ { n }$ . In Section 3.1, the FC layer $\mathbf { V }$ tries to maximize the distance between $E _ { l }$ , $l = 1 , \ldots , L$ . In this section for analysis purposes, we also assume the following.
+
+Assumption 2. We have $E _ { l } \bigcap E _ { l ^ { \prime } } = \varnothing i f l \neq l ^ { \prime }$ , i.e., the supports of each class are pairwise disjoint.
+
+Our objective function is formulated as follows, which is explained in detail in the sequel:
+
+$$
+\begin{array} { r l } & { \underset { \theta , \phi } { \operatorname* { m i n } } \mathbb { E } _ { \boldsymbol { \mu } } \ell ( { \mathbf { V } } ^ { \top } ( { \mathbf { z } } ( T ) ) , y _ { i } ) } \\ & { \mathrm { s . t . } \ \mathbb { E } _ { \boldsymbol { \nu } _ { \phi } } \| f _ { \theta } ( { \mathbf { z } } ( 0 ) ) \| _ { 2 } < \epsilon , \ f _ { \theta } \in C ^ { 1 } ( \mathbb { R } ^ { n } , \mathbb { R } ^ { n } ) , } \\ & { \quad \quad \quad \mathbb { E } _ { \boldsymbol { \nu } _ { \phi } } \left[ \nabla f _ { \theta } ( { \mathbf { z } } ( 0 ) ) \right] _ { i i } < 0 , \ \forall i = 1 , \ldots , n , } \\ & { \quad \quad \mathbb { E } _ { \boldsymbol { \nu } _ { \phi } } \left[ | [ \nabla f _ { \theta } ( { \mathbf { z } } ( 0 ) ) ] _ { i i } | - \sum _ { j \neq i } | [ \nabla f _ { \theta } ( { \mathbf { z } } ( 0 ) ) ] _ { i j } | \right] > 0 , \ \forall i = 1 , \ldots , n , } \end{array}
+$$
+
+$\mathbf { z } ( 0 ) = h _ { \phi } ( x )$ , and ${ \mathbf z } ( T )$ is the output of (1) with input ${ \bf z } ( 0 )$ .
+
+Here, $\ell$ is a loss function and $\epsilon > 0$ is a positive constant. The constraints (3) to (5) force ${ \bf z } ( 0 )$ to be near the Lyapunov-stable equilibrium points with strictly diagonally dominant derivatives. We limit the $f _ { \theta }$ to be in $C ^ { 1 } ( \mathbb { R } ^ { n } , \mathbb { R } ^ { n } )$ to satisfy the condition in Theorem 1. From [21], we also know that standard multi-layer feed forward networks with as few as a single hidden layer and arbitrary bounded and non-constant activation function are universal approximators for $C ^ { 1 ^ { \prime } } ( \mathbb { R } ^ { n } , \mathbb { R } ^ { n } )$ functions with respect to some performance criteria provided only that sufficiently many hidden units are available.
+
+As a comparison, TisODE [6] only includes a constraint similar to (3), which in general provides no guarantee to force ${ \bf z } ( 0 )$ near the Lyapunov-stable equilibrium points. In the extreme case with parameters $\theta = 0$ for $f _ { \theta }$ such that $f _ { \pmb { \theta } } = 0$ , the ODE degenerates to an identity mapping. No $\mathbf { z } ( 0 ) \in \mathbb { R } ^ { n }$ can now be a Lyapunov-stable equilibrium point, and no stability can therefore be guaranteed to defend against adversarial attacks even though the ODE curves still possess the nonintersecting property and steady-state constraint, which were cited as reasons for the stability of TisODE.
+
+Instead of directly optimizing the above objective function, in our implementation, we optimize the following empirical Lagrangian with a training set $\left\{ \left( x _ { k } , y _ { k } \right) : k = 1 , { \overset { - } { \ldots } } , N \right\}$ :
+
+$$
+\begin{array} { l } { \displaystyle \operatorname* { m i n } _ { \theta , \phi } \frac { 1 } { N } \sum _ { k = 0 } ^ { N - 1 } \bigg ( \ell \big ( \mathbf { V } ^ { \top } \mathbf { z } _ { k } ( T ) , y _ { k } \big ) + \alpha _ { 1 } \| f _ { \theta } \big ( \mathbf { z } _ { k } ( 0 ) \big ) \| _ { 2 } + \alpha _ { 2 } g _ { 1 } \Big ( \displaystyle \sum _ { i = 1 } ^ { n } [ \nabla f _ { \theta } ( \mathbf { z } _ { k } ( 0 ) ) ] _ { i i } \Big ) } \\ { \displaystyle \quad \quad + \alpha _ { 3 } g _ { 2 } \Big ( \displaystyle \sum _ { i = 1 } ^ { n } ( - | [ \nabla f _ { \theta } ( \mathbf { z } _ { k } ( 0 ) ) ] _ { i i } | + \displaystyle \sum _ { j \neq i } \vert [ \nabla f _ { \theta } ( \mathbf { z } _ { k } ( 0 ) ) ] _ { i j } | ) \Big ) \bigg ) } \end{array}
+$$
+
+s. t. $\mathbf { z } _ { k } ( 0 ) = h _ { \phi } ( x _ { k } )$ , and ${ \mathbf z } _ { k } ( T )$ is the output of (1) with input $\mathbf { z } _ { k } ( 0 ) , \forall k = 1 , . . . , N$ (8)
+
+where $\alpha _ { 1 } , \alpha _ { 2 }$ and $\alpha _ { 3 }$ are hyperparameter weights, $g _ { 1 }$ and $g _ { 2 }$ are chosen monotonically increasing functions bounded below to eliminate the unbounded impact of the two regularizers that can otherwise dominate the loss. In this paper, we set $g _ { 1 } ( \cdot ) = g _ { 2 } ( \cdot ) \bar { = } \exp ( \cdot )$ . We call these two latter terms the SODEF regularizers.
+
+Suppose for each class $l = 1 , \ldots , L$ , the embedding feature set $E _ { l } = \{ \mathbf { z } _ { 1 } ^ { ( l ) } , \dots , \mathbf { z } _ { k } ^ { ( l ) } \}$ z(l)k } is finite. For each $i = 1 , \ldots , k$ , let $\mathbf { A } _ { i } \in \mathbb { R } ^ { n \times n }$ be strictly diagonally dominant matrix with every main diagonal entry be negative such that the eigenvalues for $\mathbf { A } _ { i }$ all have negative real part. From Theorem 3, each $\mathbf { A } _ { i }$ is non-singular and every eigenvalue of $\mathbf { A } _ { i }$ has negative real part. Therefore, from Theorem 2 and Lemma 1, there exists a function $f _ { \theta }$ such that all $\mathbf { z } _ { i } ^ { ( l ) }$ are Lyapunov-stable equilibrium points with corresponding first derivative $\nabla f _ { \pmb \theta } ( \mathbf z _ { i } ^ { ( l ) } ) = \mathbf { A } _ { i }$ . This shows that if there exist only finite representation points for each class, we can find a function $f _ { \theta }$ such that all inputs to the neural ODE layer are Lyapunov-stable equilibrium points for $f _ { \theta }$ and
+
+$$
+\begin{array} { r l } & { \mathbb { E } _ { \boldsymbol \nu _ { \phi } } \left\| f _ { \boldsymbol \theta } ( \mathbf { z } ( 0 ) ) \right\| _ { 2 } = 0 , } \\ & { \mathbb { E } _ { \boldsymbol \nu _ { \phi } } \left[ \nabla f _ { \boldsymbol \theta } ( \mathbf { z } ( 0 ) ) \right] _ { i i } < 0 , \forall i = 1 , \ldots , n , } \\ & { \mathbb { E } _ { \boldsymbol \nu _ { \phi } } \left[ | [ \nabla f _ { \boldsymbol \theta } ( \mathbf { z } ( 0 ) ) ] _ { i i } | - \sum _ { j \neq i } \vert [ \nabla f _ { \boldsymbol \theta } ( \mathbf { z } ( 0 ) ) ] _ { i j } \vert \right] > 0 , \forall i = 1 , \ldots , n . } \end{array}
+$$
+
+If the input space $X$ has infinite cardinality, then an injective and continuous feature extractor $h _ { \phi }$ results in a $\nu _ { \phi }$ with non-finite support, i.e., at least one $E _ { l }$ , $l = 1 , \ldots , L$ , is infinite. It is not obvious whether we can obtain a $f _ { \theta }$ where every point in $\textstyle E = \bigcup _ { l } E _ { l }$ is a stable equilibrium point. The following result gives a negative answer if $\nu _ { \phi }$ is a continuous measure (i.e., absolutely continuous with respect to (w.r.t.) Lebesgue measure) on some subset.
+
+Lemma 3. If the restriction of $\nu _ { \phi }$ to some open set $E ^ { \prime } \subset E$ is a continuous measure, there is no continuous function fθ such that for $\nu _ { \phi }$ -almost surely all $\mathbf { z } \in E$ , $f _ { \pmb \theta } ( \mathbf z ) = 0$ and all the eigenvalues of $\nabla f _ { \boldsymbol { \theta } } ( \mathbf { z } )$ have negative real parts. In other words, there is no continuous function fθ such that almost surely all $\mathbf { z }$ in $E$ are Lyapunov-stable equilibrium points.
+
+Lemma 3 indicates that it is too much to hope for all points in $E$ to be Lyapunov-stable equilibrium points. In the following, we relax this requirement and show that under mild conditions, for all $\epsilon > 0$ , we can find a continuous function $f _ { \theta }$ with finitely many stable equilibrium points such that conditions (b) and (c) above hold and condition (a) is replaced by $\mathbb { E } _ { \boldsymbol { \nu } _ { \phi } } \bar { \| } f _ { \theta } ( \mathbf { z } ( 0 ) ) \| _ { 2 } ^ { - } < \epsilon$ . This motivates the optimization constraints in (3) to (5).
+
+Theorem 4. Suppose Assumptions $I$ and 2. If $\nu _ { \phi }$ is not a continuous uniform measure on $E _ { l }$ for each $l = 1 , \ldots , L$ , then the following holds: 1) The function space satisfying the constraints in (3) to (5) is non-empty for all $\epsilon > 0$ . 2) If additionally the restriction of $\nu _ { \phi }$ to any open set $O \subset E _ { l }$ is not a continuous uniform measure, there exist functions in this space such that each support $E _ { l }$ contains at least one Lyapunov-stable equilibrium point.
+
+# 4 Experiments
+
+In this section, we evaluate the robustness of SODEF under adversarial attacks with different attack parameters. We conduct experiments to compare the robustness of ODE net [9] and TisODE net [6] on three standard datasets: MNIST [2], CIFAR10 and CIFAR100 [3]. Since SODEF is compatible with many defense methods, it can be applied to any neural network’s final regressor layer to enhance its stability against adversarial attacks. Our experiment codes are provided in https://github.com/KANGQIYU/SODEF.
+
+# 4.1 Setup
+
+We use open-source pre-trained models that achieve the top accuracy on each dataset as the feature extractor $h _ { \phi }$ . Specifically for simple MNIST task, we use the ResNet18 model provided in Pytorch. We use the model provided by [22], which obtains nearly $8 8 \%$ clean accuracy on CIFAR100 using EfficientNet [23] and the model provided by [24], which has nearly $9 5 \%$ clean accuracy on CIFAR10. In the neural ODE layer, $f _ { \theta }$ consists of 2 FC layers. During the trainings of SODEF (except in the experiment included in Section 4.2), we train the neural network with the fixed FC introduced in Section 3.1. In the first 30 epochs, we fixed $f _ { \theta }$ to let the feature extractor $h _ { \phi }$ learn a feature representation with only the cross-entropy loss $\ell$ , and in the remaining 120 epochs, we release $h _ { \phi }$ to further train $f _ { \theta }$ using (7) with $\alpha _ { 1 } = 1$ and $\alpha _ { 2 } = \alpha _ { 3 } = 0 . 0 5$ . For CIFAR10 and CIFAR100, the pixel values are normalized by $( x - \mu ) / \sigma$ where $\mu = [ 0 . 4 9 1 4 , 0 . 4 8 2 2 , 0 . 4 4 6 5 ]$ and $\sigma = [ 0 . 2 0 2 3 , 0 . 1 9 9 4 , 0 . 2 0 1 0 ] ^ { 4 }$ . To show that our SODEF is compatible with many defense methods and can be applied to any neural network’s final regression layer, we conduct an experiment where we use a recently proposed robust network TRADES [25] as the feature extractor in our SODEF. The pretrained model is provided here 5, and we choose the model with architecture "WRN- $3 4 \mathrm { - } 1 0 "$ to conduct our experiments. Besides the two vanilla white-box attacks FGSM and PGD as metioned in Section 3.1, we also include a strong ensemble attack AutoAttack [26], which sequentially performs attack using all of the following four individual attacks: three white-box attacks APGDCE, APGDTDLR and FABT[27], and one black-box Square attack [28]. We refer the reader to the the supplementary material for more details of the attacks used in this paper, where, in additional, more experiments are included.
+
+# 4.2 Compatibility of SODEF
+
+Adversarial training (AT) is one of the most effective strategies for defending adversarial attacks. TRADES [25] is one of the adversarial training defense methods with combinations of tricks of warmup, early stopping, weight decay, batch size and other hyper parameter settings. In this experiment we fix the pretained TRADES model (except the final FC layer (size $6 4 0 \mathrm { x } 1 0 )$ ) as our feature extractor $h _ { \phi }$ . We then append our (trainable) SODEF with integration time $T = 5$ to the output of the feature extractor. To evaluate model robustness, we use AutoAttack and attack the models using both the $\mathcal { L } _ { 2 }$ norm $\epsilon = 0 . 5$ ) and $\mathcal { L } _ { \infty }$ norm $( \epsilon = 8 / 2 5 5 )$ ). The results are shown in Table 3. We clearly observe that our SODEF can enhance TRADES’s robustness under all the four individual attacks and the strongest ensemble AutoAttack. For the strong $\mathcal { L } _ { 2 }$ AutoAttack, our SODEF have improved the model robustness from $5 9 . 4 2 \%$ to $6 7 . 7 5 \%$ . Our experiment show that SODEF can be applied to many defense models’ regression layer to enhance their stability against attacks.
+
+Table 3: Classification accuracy $( \% )$ using TRADES (w/ and w/o SODEF) under AutoAttack on adversarial CIFAR10 examples with $\mathcal { L } _ { 2 }$ norm $\epsilon = 0 . 5 )$ and $\mathcal { L } _ { \infty }$ norm $( \epsilon = 8 / 2 5 5 )$ .   
+
+<table><tr><td colspan="4">Attack /ModelTRADES LTRADES+SODEF LTRADES L2TRADES+SODEF L2</td></tr><tr><td>Clean</td><td>85.48</td><td>85.18</td><td>85.48 85.18</td></tr><tr><td>APGDcE</td><td>56.08</td><td>70.90</td><td>61.74 74.35</td></tr><tr><td>APGDDLR</td><td>53.70</td><td>64.15</td><td>59.22 68.55</td></tr><tr><td>FABT</td><td>54.18</td><td>82.92</td><td>60.31 83.15</td></tr><tr><td>Square</td><td>59.12</td><td>62.21</td><td>72.65 76.02</td></tr><tr><td>AutoAttack</td><td>53.69</td><td>57.76</td><td>59.42 67.75</td></tr></table>
+
+# 4.3 Influence of Integration Time $T$
+
+From the discussion after Theorems 1 and 2, we know if the malicious perturbations around the ODE input Lyapunov-stable equilibrium point ${ \bf z } ( 0 )$ is small, then the output ${ \mathbf z } ( T )$ for large enough $T$ will not be affected significantly by the perturbation: $\| \tilde { { \mathbf z } } ( t ) - { \mathbf z } ( 0 ) \| _ { 2 } \dot { \to } 0$ as $t \to \infty$ . Consequently, the succeeding network layers after the neural ODE layer can still perform well without being affected by the input perturbation. In this section, we test the influence of the SODEF integration time $T$ using CIFAR100. We use the model EfficientNet provided by [23] as $h _ { \phi }$ (Note, unlike Section 4.2, $h _ { \phi }$ is trainable in this experiments). We use AutoAttack with $\mathcal { L } _ { 2 }$ norm $\epsilon = 0 . 5$ ). We observe that for all the four individual attacks and the strongest ensemble AutoAttack, SODEF performs generally better for large integration time $T$ . We also test larger integration time $T > 1 0$ , but do not see any obvious improvements.
+
+# 4.4 Performance Comparison Under AutoAttack
+
+For a comparison, we provide the results of applying AutoAttack to other baseline models mentioned in the paper. We set the same integration time for ODE, TisODE and SODEF. We observe that for the
+
+Table 4: Classification accuracy $( \% )$ under AutoAttack on adversarial CIFAR100 examples with $\mathcal { L } _ { 2 }$ norm, $\epsilon = 0 . 5$ and different integration time $T$ for SODEF.   
+
+<table><tr><td>Attack/T</td><td>1</td><td>3</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>Clean</td><td>88.00</td><td>88.12</td><td>88.15</td><td>88.00</td><td>87.92</td><td>88.00</td><td>88.05</td><td>88.10</td></tr><tr><td>APGDcE</td><td>17.20</td><td>21.33</td><td>21.05</td><td>23.67</td><td>69.67</td><td>85.33</td><td>87.10</td><td>86.88</td></tr><tr><td>APGDLR</td><td>21.02</td><td>21.00</td><td>22.00</td><td>26.00</td><td>63.30</td><td>86.90</td><td>86.20</td><td>86.54</td></tr><tr><td>FABT</td><td>86.33</td><td>85.10</td><td>86.36</td><td>87.70</td><td>87.67</td><td>86.55</td><td>86.22</td><td>85.93</td></tr><tr><td>Square</td><td>84.67</td><td>86.22</td><td>87.05</td><td>87.20</td><td>86.90</td><td>86.33</td><td>87.05</td><td>86.75</td></tr><tr><td>AutoAttack</td><td>2.00</td><td>3.53</td><td>4.87</td><td>4.33</td><td>30.66</td><td>78.80</td><td>78.97</td><td>79.10</td></tr></table>
+
+strongest AutoAttack, our SODEF outperforms the other baseline models by a significant margin. In this case, SODEF achieves $7 9 . 1 0 \%$ accuracy while other models only get less than $3 \%$ accuracy.
+
+Table 5: Classification accuracy $( \% )$ under AutoAttack on adversarial CIFAR100 examples with $\mathcal { L } _ { 2 }$ norm, $\epsilon = 0 . 5$ and $T = 1 0$ .   
+
+<table><tr><td>Attack/Model</td><td>NoODE</td><td>ODE</td><td>TisODE</td><td>SODEF</td></tr><tr><td>Clean</td><td>88.00</td><td>87.90</td><td>88.00</td><td>88.10</td></tr><tr><td>APGDCE</td><td>23.30</td><td>6.75</td><td>14.32</td><td>86.88</td></tr><tr><td></td><td>7.33</td><td>22.00</td><td>24.20</td><td>86.54</td></tr><tr><td>FAB</td><td>79.30</td><td>78.67</td><td>77.16</td><td>85.93</td></tr><tr><td>Square</td><td>84.52</td><td>85.67</td><td>86.32</td><td>86.75</td></tr><tr><td>AutoAttack</td><td>0.00</td><td>1.33</td><td>4.06</td><td>79.10</td></tr></table>
+
+# 4.5 Performance Under PGD and FGSM Attacks
+
+White-box adversaries have knowledge of the classifier models, including training data, model architectures and parameters. We test the performance of our model in defending against the whitebox attacks, PGD and FGSM. We set $T = 5$ as the integration time for the neural ODE layer. The parameters for different attack methods used are given in the supplementary material. The subsequent experiments use these settings by default, unless otherwise stated.
+
+Table 6: Classification accuracy $( \% )$ on adversarial MNIST examples.   
+
+<table><tr><td>Attack</td><td>Para.</td><td>no ode</td><td>ODE</td><td>TisODE</td><td>SODEF</td></tr><tr><td>None</td><td>-</td><td>99.45</td><td>99.42</td><td>99.43</td><td>99.44</td></tr><tr><td>FGSM</td><td>∈=0.3</td><td>10.03</td><td>29.6</td><td>36.70</td><td>63.36</td></tr><tr><td>PGD</td><td>∈= 0.3</td><td>0.31</td><td>1.56</td><td>1.82</td><td>45.25</td></tr></table>
+
+The classification results on MNIST are shown in Table 6. We observe that while maintaining the state-of-the-art accuracy on normal images, SODEF improves the adversarial robustness as compared to the other two methods. For the most effective attack in this experiment, i.e., PGD attack, SODEF shows a $4 5 . 2 5 \% - 1 . 5 6 \% = 4 3 . 6 9 \%$ improvement over ODE and a $4 5 . 2 5 \% - 1 . 2 3 \% = 4 4 . 0 2 \%$ improvement over TisODE.
+
+Table 7: Classification accuracy $( \% )$ on adversarial CIFAR10 examples.   
+
+<table><tr><td>Attack</td><td>Para.</td><td>no ode</td><td>ODE</td><td>TisODE</td><td>SODEF</td></tr><tr><td>None</td><td>-</td><td>95.2</td><td>94.9</td><td>95.1</td><td>95.0</td></tr><tr><td>FGSM</td><td>∈=0.1</td><td>47.31</td><td>45.23</td><td>43.28</td><td>68.05</td></tr><tr><td>PGD</td><td>∈=0.1</td><td>3.09</td><td>3.21</td><td>3.80</td><td>55.59</td></tr></table>
+
+For CIFAR-10, we see from Table 7 that SODEF maintains high accuracy on normal examples and makes the best predictions under adversarial attacks. In particular, SODEF achieves an absolute percentage point improvement over ODE net up to $5 2 . 3 8 \%$ and over TisODE up to $5 2 . 5 4 \%$ for PGD attack.
+
+For CIFAR-100, the results in the supplementary material shows that the most effective attack causes the classification accuracy to drop relatively by $\begin{array} { r } { 7 4 . 6 \% = \frac { 8 8 . 0 - 2 2 . 3 5 } { 8 8 . 0 } } \end{array}$ 88.0−22.35 for SODEF and by $\begin{array} { r } { 9 7 . 3 \% = \frac { 8 8 . 3 - 2 . 3 9 } { 8 8 . 3 } } \end{array}$ for vanilla EfficientNet, which is pre-trained on ImageNet to obtain a top clean accuracy. Neither ODE net nor TisODE net can improve the classification accuracy under PGD attack by a big margin, e.g. TisODE net only improves the classification accuracy from $2 . 3 9 \%$ to $3 . 4 4 \%$ , while SODEF still shows clear defense capability in this scenario.
+
+# 4.6 Ablation Studies
+
+The impact of the ODE with and without the SODEF regularizers in (7) has been presented in the above comparisons between SODEF and ODE. In this section, we show the necessity of diversity promoting using the FC introduced in Section 3.1 and conduct transferability study.
+
+# 4.6.1 Impact of Diversity Promotion
+
+Table 8: Classification accuracy $( \% )$ on adversarial MNIST examples, where the superscript indicates the last FC layer is not fixed to be $\mathbf { V }$ and is set to be a trainable layer.   
+
+<table><tr><td>Attack</td><td>Para.</td><td>SODEF</td><td>SODEF-</td></tr><tr><td>None</td><td>-</td><td>95.0</td><td>95.1</td></tr><tr><td>FGSM</td><td>∈=0.1</td><td>63.36</td><td>51.6</td></tr><tr><td>PGD</td><td>∈=0.1</td><td>45.25</td><td>34.9</td></tr></table>
+
+Table 8 shows the difference of the defense performance when fixing the final FC be $\mathbf { V }$ or setting it to a trainable linear layer. It can be seen that having diversity control improves the robustness. One possible reason for this phenomenon given in Section 3 is that diversity promotion with a fixed designed FC attempts to make the embedding feature support $E _ { l }$ of each class $l$ disjoint to each other and therefore the Lyapunov-stable equilibrium points for each $E _ { l }$ are well separated.
+
+# 4.6.2 Transferability Study
+
+Transferability study is carried out on CIFAR-10, where the adversarial examples are generated using FGSM and PGD attacks using ResNet18 without any ODEs. The classification accuracy drops from $6 8 . 0 5 \%$ to $5 9 \%$ for FGSM with $\epsilon = 0 . 3$ , and from $5 5 . 5 9 \%$ to $3 4 \%$ for PGD with $\epsilon = 0 . 1$ . One possible reason for this phenomenon is that ODEs have obfuscated gradient masking effect as discussed in [15], and a transfer attack may deteriorate the defense effect. However, as we observe from Table 7, even with a transfer attack on SODEF, it still performs better than other ODEs without transfer attacks.
+
+# 5 Conclusion
+
+In this paper, we have developed a new neural ODE network, SODEF, to suppress input perturbations. SODEF is compatible with any existing neural networks and can thus be appended to the state-of-theart networks to increase their robustness to adversarial attacks. We demonstrated empirically and theoretically that the robustness of SODEF mainly derives from its stability and proposed a training method that imposes constraints to ensure all eigenvalues of the Jacobian matrix of the neural ODE layer have negative real parts. When each classification class converges to its own equilibrium points, we showed that the last FC layer can be designed in such a way that the distance between the stable equilibrium points is maximized, which further improves the network’s robustness. The effectiveness of SODEF has been verified under several popular while-box attacks.
+
+# Acknowledgments and Disclosure of Funding
+
+This research is supported in part by A\*STAR under its RIE2020 Advanced Manufacturing and Engineering (AME) Industry Alignment Fund – Pre Positioning (IAF-PP) (Grant No. A19D6a0053) and the RIE2020 Industry Alignment Fund – Industry Collaboration Projects (IAF-ICP) Funding Initiative, as well as cash and in-kind contribution from the industry partner(s). The computational work for this article was partially performed on resources of the National Supercomputing Centre, Singapore (https://www.nscc.sg).
+
+# Broader Impact
+
+Our work, which contributes to more robust DNNs, is supposed to mitigate the threat of adversarial attacks. However, on the hand, the reliable deployment of DNNs in automation of tasks will potentially bring mass-scale unemployment and social unrest. As DNNs become more robust and more tasks, especially those whose failures will bring high risks to human lives or large property losses under adversarial attacks, fall into the automatic task category, massive jobs could disappear.
+
+# References
+
+[1] A. Krizhevsky, I. Sutskever, and G. E. Hinton, “ImageNet classification with deep convolutional neural networks,” in Proc. Advances Neural Inf. Process. Syst., 2012.   
+[2] Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” Proceedings of the IEEE, vol. 86, no. 11, pp. 2278–2324, Nov. 1998.   
+[3] G. Hinton, L. Deng, D. Yu, G. E. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury, “Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups,” IEEE Signal Process. Mag., vol. 29, no. 6, pp. 82–97, Nov. 2012.   
+[4] D. Andor, C. Alberti, D. Weiss, A. Severyn, A. Presta, K. Ganchev, S. Petrov, and M. Collins, “Globally normalized transition-based neural networks,” in Proc. Annu. Meeting Assoc, Comput. Linguistics, 2016.   
+[5] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus, “Intriguing properties of neural networks,” in Proc. Int. Conf. Learning Representations, 2013.   
+[6] H. Yan, J. Du, V. Y. Tan, and J. Feng, “On robustness of neural ordinary differential equations,” in Proc. Advances Neural Inf. Process. Syst., 2018, pp. 1–13.   
+[7] E. Haber and L. Ruthotto, “Stable architectures for deep neural networks,” Inverse Problems, vol. 34, no. 1, pp. 1–23, Dec. 2017.   
+[8] X. Liu, S. Si, Q. Cao, S. Kumar, and C.-J. Hsieh, “How does noise help robustness? Explanation and exploration under the neural sde framework,” in Proc. Conf. Comput. Vision Pattern Recognition, 2020, pp. 282–290.   
+[9] R. T. Chen, Y. Rubanova, J. Bettencourt, and D. Duvenaud, “Neural ordinary differential equations,” arXiv preprint arXiv:1806.07366, 2018.   
+[10] C.-T. Chen and B. Shafai, Linear system theory and design. New York: Oxford university press New York, 1999.   
+[11] Y. LeCun, C. Corte, and C. Burges, “MNIST handwritten digit database,” ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, vol. 2, 2010, (Last accessed: Dec 1, 2020).   
+[12] A. Krizhevsky and G. Hinton, “Learning multiple layers of features from tiny images,” Master’s thesis, Department of Computer Science, University of Toronto, 2009.   
+[13] A. M ˛adry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu, “Towards deep learning models resistant to adversarial attacks,” in Proc. Int. Conf. Learning Representations, 2018.   
+[14] E. Haber and L. Ruthotto, “Stable architectures for deep neural networks,” Inverse Problems, vol. 34, no. 1, 2018.   
+[15] Y. Huang, Y. Yu, H. Zhang, Y. Ma, and Y. Yao, “Adversarial robustness of stabilized neuralodes might be from obfuscated gradients,” arXiv preprint arXiv:2009.13145, 2020.   
+[16] L. Mingjie, H. Lingshen, and L. Zhouchen, “Implicit Euler skip connections: Enhancing adversarial robustness via numerical stability,” in Proc. Int. Conf. Machine Learning, 2020.   
+[17] I. J. Goodfellow, J. Shlens, and C. Szegedy, “Explaining and harnessing adversarial examples,” in Proc. Int. Conf. Learning Representations, 2015.   
+[18] D. Arrowsmith and C. M. Place, Dynamical systems: differential equations, maps, and chaotic behaviour. London: CRC Press, 1992.   
+[19] R. A. Horn and C. R. Johnson, Matrix analysis. New York: Cambridge university press, 2012.   
+[20] L. Van der Maaten and G. Hinton, “Visualizing data using t-sne,” J. Mach. Learning Res., vol. 9, no. 11, pp. 2580–2605, Nov. 2008.   
+[21] K. Hornik, “Approximation capabilities of multilayer feedforward networks,” Neural Networks, vol. 4, no. 2, pp. 251–257, Oct. 1991.   
+[22] Y. Luo, Y. Wong, S. M. Kankanhalli, and Q. Zhao, “Direction concentration learning: Enhancing congruency in machine learning,” IEEE Trans. Pattern Anal. Mach. Intell., vol. 43, no. 1, pp. 1928 – 1946, Jun. 2021.   
+[23] M. Tan and Q. Le, “Efficientnet: Rethinking model scaling for convolutional neural networks,” in Proc. Int. Conf. Mach. Learning, 2019, pp. 6105–6114.   
+[24] Github pytorch-cifar repository. Accessed: May 1, 2021. [Online]. Available: https: //github.com/kuangliu/pytorch-cifar   
+[25] T. Pang, X. Yang, Y. Dong, H. Su, and J. Zhu, “Bag of tricks for adversarial training,” in Proc. Int. Conf. Learning Representations, 2021.   
+[26] F. Croce and M. Hein, “Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks,” in Proc. Int. Conf. Mach. Learning, 2020, pp. 2206–2216.   
+[27] ——, “Minimally distorted adversarial examples with a fast adaptive boundary attack,” in Proc. Int. Conf. Mach. Learning, 2020, pp. 2196–2205.   
+[28] M. Andriushchenko, F. Croce, N. Flammarion, and M. Hein, “Square attack: a query-efficient black-box adversarial attack via random search,” in Proc. European Conf. Comput. Vision. Springer, 2020, pp. 484–501.
+
+# 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]   
+(c) Did you discuss any potential negative societal impacts of your work? [Yes]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] . See Assumption 1 and Assumption 2   
+(b) Did you include complete proofs of all theoretical results? [Yes] . See supplementary material.
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] .   
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] . See Sections 3.1 and 4   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] Having ODE blocks in our model, it would be too computationally expensive to repeat experiments for many times. We repeated each experiment for 2-3 times and we observe the deviation of the classification results is within $\pm 3 \%$ , though these experimental repetitions are not enough to construct error bars.   
+(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 3.1.
+
+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] See Sections 3.1 and 4 for the open-source models we have used from GitHub.   
+(b) Did you mention the license of the assets? [No] . Please see the licenses given in the GitHub link.   
+(c) Did you include any new assets either in the supplemental material or as a URL? [No] No new assets.   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] MNIST, CIFAR-10 and CIFAR-100 are all open-source datasets.   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] There is no identifiable information or offensive content in the datasets.
+
+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/9CPc4EIr2t1/9CPc4EIr2t1_content_list.json

@@ -0,0 +1,1372 @@
+[
+    {
+        "type": "text",
+        "text": "Stable Neural ODE with Lyapunov-Stable Equilibrium Points for Defending Against Adversarial Attacks ",
+        "text_level": 1,
+        "bbox": [
+            245,
+            122,
+            753,
+            196
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Qiyu Kang∗ ",
+        "text_level": 1,
+        "bbox": [
+            289,
+            247,
+            372,
+            261
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Continental-NTU Corporate Lab Nanyang Technological University 50 Nanyang Avenue, 639798, Singapore kang0080@e.ntu.edu.sg ",
+        "bbox": [
+            196,
+            262,
+            460,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yang Song∗ School of Electrical and Electronic Engineering Nanyang Technological University 50 Nanyang Avenue, 639798, Singapore songy@ntu.edu.sg ",
+        "bbox": [
+            488,
+            247,
+            803,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Qinxu Ding ",
+        "text_level": 1,
+        "bbox": [
+            287,
+            338,
+            369,
+            352
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "School of Business   \nSingapore University of Social Sciences   \n463 Clementi Road, 599494, Singapore qinxuding@suss.edu.sg ",
+        "bbox": [
+            196,
+            353,
+            459,
+            407
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wee Peng Tay School of Electrical and Electronic Engineering Nanyang Technological University 50 Nanyang Avenue, 639798, Singapore wptay@ntu.edu.sg ",
+        "bbox": [
+            488,
+            338,
+            802,
+            407
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            443,
+            535,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep neural networks (DNNs) are well-known to be vulnerable to adversarial attacks, where malicious human-imperceptible perturbations are included in the input to the deep network to fool it into making a wrong classification. Recent studies have demonstrated that neural Ordinary Differential Equations (ODEs) are intrinsically more robust against adversarial attacks compared to vanilla DNNs. In this work, we propose a stable neural ODE with Lyapunov-stable equilibrium points for defending against adversarial attacks (SODEF). By ensuring that the equilibrium points of the ODE solution used as part of SODEF is Lyapunov-stable, the ODE solution for an input with a small perturbation converges to the same solution as the unperturbed input. We provide theoretical results that give insights into the stability of SODEF as well as the choice of regularizers to ensure its stability. Our analysis suggests that our proposed regularizers force the extracted feature points to be within a neighborhood of the Lyapunov-stable equilibrium points of the ODE. SODEF is compatible with many defense methods and can be applied to any neural network’s final regressor layer to enhance its stability against adversarial attacks. ",
+        "bbox": [
+            233,
+            476,
+            766,
+            695
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            310,
+            741
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although deep learning has found successful applications in many tasks such as image classification [1, 2], speech recognition [3], and natural language processing [4], the vulnerability of deep learning to adversarial attacks (e.g., see [5]) has limited its real-world applications due to performance and safety concerns in critical applications. Inputs corrupted with human-imperceptible perturbations can easily fool many vanilla deep neural networks (DNNs) into mis-classifying them and thus significantly impact their performance. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            839
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent studies [6–8] have applied neural Ordinary Differential Equations (ODEs) [9] to defend against adversarial attacks. Some works like [6] have revealed interesting intrinsic properties of ",
+        "bbox": [
+            176,
+            845,
+            821,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ODEs that make them more stable than conventional convolutional neural networks (CNNs). The paper [6] proposes a time-invariant steady neural ODE (TisODE) using the property that the integral curves from a ODE solution starting from different initial points (inputs) do not intersect and always preserve uniqueness in the solution function space. However, this does not guarantee that small perturbations of the initial point lead to small perturbations of the integral curve output at a later time $T$ . The authors thus proposed a regularizer to limit the evolution of the curves by forcing the integrand to be close to zero. However, neither the non-intersecting property nor the steady-state constraint used in TisODE can guarantee robustness against input perturbations since these constraints do not ensure that the inputs are within a neighborhood of Lyapunov-stable equilibrium points. An example is an ODE that serves as an identity mapping is not robust to input perturbations but satisfies all the constraints proposed in [6]. ",
+        "bbox": [
+            174,
+            90,
+            825,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, our objective is to design a neural ODE such that the features extracted are within a neighborhood of the Lyapunov-stable equilibrium points of the ODE. We first develop a diversity promoting technique applied in the final fully connected (FC) layer to improve the ODE’s stability and analyze the reasons why. We then propose a stable neural ODE with Lyapunov-stable equilibrium points to eliminate the effects of perturbations in the input. From linear control theory [10], a linear time-invariant system $\\mathrm { d } { \\mathbf { z } ( t ) } / \\mathrm { d } t = { \\mathbf { A } } { \\mathbf { z } ( t ) }$ , where $\\mathbf { A }$ is a constant matrix, is exponentially stable if all eigenvalues of $\\mathbf { A }$ have negative real parts. Specifically, we propose to force the Jacobian matrix of the ODE used in the neural ODE to have eigenvalues with negative real parts. Instead of directly imposing constraints on the eigenvalues of the matrix, which lead to high computational complexity when the Jacobian matrix is large, we instead add constraints to the matrix elements to implicitly force the real parts of its eigenvalues to be negative. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            401
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our main contributions are summarized as follows: ",
+        "bbox": [
+            174,
+            409,
+            509,
+            422
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "1. Based on the concept of Lyapunov-stable equilibrium points, we propose a simple yet effective technique to improve the robustness of neural ODE networks by fixing the final FC layer to be a matrix whose rows have unit norm and such that the maximum cosine similarity between any two rows is minimized. Such a FC layer can be constructed off-line.   \n2. We propose a stable neural ODE for deFending against adversarial attacks (SODEF) to suppress the input perturbations. We derive an optimization formulation for SODEF to force the extracted feature points to be within a neighborhood of the Lyapunov-stable equilibrium points of the SODEF ODE. We provide sufficient conditions for learning a robust feature representation under SODEF.   \n3. We test SODEF on several widely used datasets MNIST [11], CIFAR-10 and CIFAR-100 [12] under well-known adversarial attacks. We demonstrate that SODEF is robust against adversarial white-box attacks with improvement in classification accuracy of adversarial examples under PGD attack [13] of up to $4 4 . 0 2 \\%$ , $5 2 . 5 4 \\%$ and $1 8 . 9 1 \\%$ percentage points compared to another current state-of-the-art neural ODE network TisODE [6] on MNIST, CIFAR-10 and CIFAR-100, respectively. Similar improvements in classification accuracy of adversarial examples of up to $\\bar { 4 3 . 6 9 \\% }$ , $5 2 . 3 8 \\%$ and $\\mathrm { \\bar { 1 8 . 9 9 \\% } }$ percentage points compared to ODE net [9] are also obtained. ",
+        "bbox": [
+            210,
+            436,
+            825,
+            699
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The rest of this paper is organized as follows. We provide essential preliminaries on neural ODE and its stability analysis in Section 2. In Section 3, we present SODEF model architecture and its training method. We show how to maximize the distance between stable equilibrium points of neural ODEs. We propose an optimization and present theoretical results on its stability properties. We summarize experimental results in Section 4 and conclude the paper in Section 5. The proofs for all lemmas and theorems proposed in this paper are given in the supplementary material. We also refer interested readers to the supplementary material for a more detailed account of related works [14–16, 6] and some popular adversarial attacks [17, 13] that are used to verify the robustness of our proposed SODEF. In the paper, we use lowercase boldface characters like $\\mathbf { z }$ to denote vectors in $\\mathbb { R } ^ { n }$ , capital boldface characters like $\\mathbf { A }$ to denote matrices in $\\mathbb { R } ^ { n \\times n }$ , and normal characters like $z$ to denote scalars except that the notation $( x , y )$ are normal characters reserved to denote the input and label pairs. A vector $\\mathbf { z } \\in \\mathbb { R } ^ { n }$ is represented as $( \\mathbf { z } ^ { ( 1 ) } , \\mathbf { z } ^ { ( 2 ) } , \\ldots , \\mathbf { z } ^ { ( n ) } )$ . The $( i , j )$ -th element of a matrix $\\mathbf { A }$ is $\\mathbf { A } _ { i j }$ or $[ \\mathbf { A } ] _ { i j }$ . The Jacobian matrix of a function $f : \\mathbb { R } ^ { n } \\mapsto \\mathbb { R } ^ { n }$ evaluated at $\\mathbf { z }$ is denoted as $\\nabla f ( \\mathbf { z } )$ The set of functions $\\mathbb { R } ^ { n } \\mapsto \\mathbb { R } ^ { n }$ with continuous first derivatives is denoted as $C ^ { 1 } ( \\mathbb { R } ^ { n } , \\mathbb { R } ^ { n } )$ . ",
+        "bbox": [
+            173,
+            714,
+            825,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Preliminaries: Neural ODE and Stability ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            88,
+            547,
+            107
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a neural ODE layer, the relation between the layer input ${ \\bf z } ( 0 )$ and output ${ \\mathbf z } ( T )$ is described as the following differential equation: ",
+        "bbox": [
+            171,
+            118,
+            823,
+            147
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/40fc799ca8fac2cda94627f8fa8e3909cd3c435bfc40eb885acf21aca9021058.jpg",
+        "text": "$$\n\\frac { \\mathrm { d } \\mathbf { z } ( t ) } { \\mathrm { d } t } = f _ { \\pmb { \\theta } } ( \\mathbf { z } ( t ) , t )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            148,
+            566,
+            179
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { \\pmb \\theta } : \\mathbb { R } ^ { n } \\times [ 0 , \\infty ) \\mapsto \\mathbb { R } ^ { n }$ denotes the non-linear trainable layers that are parameterized by weights $\\pmb { \\theta }$ and $\\mathbf { z } : [ 0 , \\infty ) \\mapsto \\mathbb { R } ^ { n }$ represents the $n$ -dimensional state of the neural ODE. Neural ODEs are the continuous analog of residual networks where the hidden layers of residual networks can be regarded as discrete-time difference equations ${ \\bf z } ( t + 1 ) = { \\bf z } ( t ) + { f _ { \\theta } } ( { \\bf z } ( t ) , t )$ . In this work, for simplicity, we only consider the time-invariant (autonomous) case $f _ { \\pmb \\theta } ( \\mathbf { z } ( t ) , t ) = f _ { \\pmb \\theta } ( \\mathbf { z } ( t ) )$ , where the dynamical system does not explicitly depend on $t$ . For such non-linear dynamical systems, the following theorem shows that under mild conditions, its behaviour can be studied via linearization near special points called hyperbolic equilibrium points. ",
+        "bbox": [
+            173,
+            180,
+            825,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1 (Hartman–Grobman Theorem [18]). Consider a system evolving in time with state $\\mathbf { z } ( t ) \\in \\mathbb { R } ^ { n }$ that satisfies the differential equation $\\frac { \\mathrm { d } { \\bf z } ( t ) } { \\mathrm { d } t } = f ( { \\bf z } ( t ) )$ for some $f \\in C ^ { 1 } ( \\mathbb { R } ^ { n } , \\mathbb { R } ^ { n } ) ;$ , $f ( \\mathbf { z } ) = ( f ^ { ( 1 ) } ( \\mathbf { z } ) , \\ldots , f ^ { ( n ) } ( \\mathbf { z } ) )$ . Suppose the map has a hyperbolic equilibrium state $\\mathbf { z } ^ { \\ast } \\in \\mathbb { R } ^ { n }$ , i.e., $f ( { \\bf z } ^ { * } ) = 0$ and the Jacobian matrix  with real part equal to zer $\\nabla f = [ \\partial f ^ { ( i ) } / \\partial \\mathbf { z } ^ { ( j ) } ] _ { i , j = 1 } ^ { n }$ of hb $f$ evalurhood at of $\\textbf { z } = \\textbf { z } ^ { * }$ has nolibrium $N _ { \\mathbf { z } ^ { * } }$ point $\\mathbf { z } ^ { \\ast }$ and a homeomorphism $g : N _ { \\mathbf { z } ^ { * } } \\mapsto \\mathbb { R } ^ { n }$ , such that $g ( \\mathbf { z } ^ { * } ) = 0$ and in the neighbourhood $N _ { \\mathbf { z } ^ { * } }$ , the flow of $\\frac { \\mathrm { d } { \\bf z } ( t ) } { \\mathrm { d } t } = f ( { \\bf z } ( t ) )$ is topologically conjugate by the continuous map $\\bar { \\mathbf { z } } ( t ) = g ( \\mathbf { z } ( t ) )$ to the flow of its linearization $\\frac { \\mathrm { d } \\bar { \\mathbf { z } } ( t ) } { \\mathrm { d } t } = \\nabla f ( \\mathbf { z } ^ { * } ) \\cdot \\bar { \\mathbf { z } } ( t ) .$ ",
+        "bbox": [
+            173,
+            292,
+            826,
+            450
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The theorem states that when the Jacobian matrix at the zeros of $f$ has no eigenvalue with zero real part, the behaviour of the original dynamical system can be studied using the simpler linearization of the system around those zeros. We next review some definitions and theorems from linear control theory [10]. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            512
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1 (Lyapunov Stability [10]). The linear time-invariant system $\\frac { \\mathrm { d } \\bar { \\mathbf { z } } ( t ) } { \\mathrm { d } t } = \\mathbf { A } \\bar { \\mathbf { z } } ( t )$ with constant matrix A is marginally stable or stable in the sense of Lyapunov if every finite initial state $\\bar { \\mathbf { z } } ( 0 )$ excites a bounded response. It is asymptotically stable if every finite initial state excites $a$ bounded response, which, in addition, approaches 0 as $t \\to \\infty$ . ",
+        "bbox": [
+            173,
+            515,
+            825,
+            583
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2 (Lyapunov Stability Theorem [10]). a) The equation $\\frac { \\mathrm { d } \\bar { \\mathbf { z } } ( t ) } { \\mathrm { d } t } = \\mathbf { A } \\bar { \\mathbf { z } } ( t ) )$ is marginally stable if and only if all eigenvalues of A have zero or negative real parts and those with zero real parts are simple roots of the minimal polynomial of A. $^ b$ ) The equation $\\frac { \\mathrm { d } \\bar { \\mathbf { z } } ( t ) } { \\mathrm { d } t } = \\mathbf { A } \\bar { \\mathbf { z } } ( t )$ is asymptotically stable if and only if all eigenvalues of A have negative real parts. ",
+        "bbox": [
+            173,
+            585,
+            825,
+            667
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In Theorem 1, we say that a hyperbolic equilibrium point is Lyapunov-stable if all eigenvalues of the Jacobian matrix evaluated at it have negative real parts. From Theorems 1 and 2, we see that a small perturbation around the Lyapunov-stable equilibrium point ${ \\bf z } ( 0 )$ leads to $\\tilde { \\mathbf { z } } ( t ) \\to \\mathbf { z } ( 0 )$ as $t \\to \\infty$ , i.e., $\\exists \\delta > 0$ such that for all $\\tilde { \\mathbf { z } } ( 0 )$ with $\\lVert { \\mathbf z } ( 0 ) \\dot { - } \\tilde { { \\mathbf z } } ( 0 ) \\rVert _ { 2 } \\dot { < } \\delta$ , we have $\\| \\widetilde { \\mathbf { z } } ( t ) - \\mathbf { z } ( 0 ) \\| _ { 2 } \\to \\dot { 0 }$ as $t \\to \\infty$ , where $\\tilde { \\mathbf { z } } ( t )$ is the ODE solution for the perturbed input $\\tilde { \\mathbf { z } } ( 0 )$ . In the context of neural network adversarial attacks, if the malicious perturbations around the ODE input ${ \\bf z } ( 0 )$ is small, then the output ${ \\mathbf z } ( T )$ for large enough $T$ will not be affected significantly by the perturbation. Consequently, the succeeding network layers after the neural ODE layer can still perform well without being affected by the input perturbation. The perturbation weakening phenomenon around Lyapunov-stable equilibrium points works like a noise filter and acts as a defense against adversarial attacks. ",
+        "bbox": [
+            173,
+            674,
+            825,
+            814
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We require the following definition and result in our stability analysis. ",
+        "bbox": [
+            174,
+            819,
+            637,
+            834
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 2 (Strictly diagonally dominant [19]). Let $\\mathbf { A } \\in \\mathbb { C } ^ { n \\times n }$ . We say that A is strictly diagonally dominant if $\\begin{array} { r } { \\left| { { { \\mathbf { A } } _ { i i } } } \\right| > \\sum _ { j \\neq i } \\left| { { { \\mathbf { A } } _ { i j } } } \\right| } \\end{array}$ for all $i = 1 , . . . , n$ . ",
+        "bbox": [
+            174,
+            835,
+            823,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Levy–Desplanques theorem [19]). If $\\mathbf { A } \\in \\mathbb { C } ^ { n \\times n }$ is strictly diagonally dominant and if every main diagonal entry of A is real and negative, then $A$ is non-singular and every eigenvalue of A has negative real part. ",
+        "bbox": [
+            174,
+            869,
+            826,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/96641a4aad1ec2c9f3138777e3d67fc9ff9849146d1c1b15becd36b84d50c353.jpg",
+        "image_caption": [
+            "Fig. 1: SODEF model architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            87,
+            815,
+            133
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. Given $k$ distinct points $\\mathbf { z } _ { i } \\in \\mathbb { R } ^ { n }$ and matrices $\\mathbf { A } _ { i } \\in \\mathbb { R } ^ { n \\times n }$ , $i = 1 , . . . , k$ , there exists a function $f \\in C ^ { 1 } ( \\mathbb { R } ^ { n } , \\mathbb { R } ^ { n } )$ such that $f ( \\mathbf { z } _ { i } ) = 0$ and $\\nabla f _ { \\pmb { \\theta } } ( \\mathbf { z } _ { i } ) = \\mathbf { A } _ { i }$ . ",
+        "bbox": [
+            171,
+            184,
+            823,
+            213
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 SODEF Architecture ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            232,
+            382,
+            250
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We consider a classification problem with $L$ classes. The proposed SODEF model architecture is shown in Fig. 1. The input $x \\in X$ (e.g., an image) is first passed through a feature extractor $h _ { \\phi } : X \\mapsto \\mathbb { R } ^ { n }$ to obtain an embedding feature representation ${ \\bf z } ( 0 )$ . A neural ODE layer $f _ { \\theta }$ follows as a nonlinear feature mapping to stabilize the feature representation output ${ \\bf z } ( 0 )$ from $h _ { \\phi }$ . The final FC layer $\\mathbf { V }$ serves as a linear mapping to generate a prediction vector based on the output $\\mathbf { \\dot { z } } ( T )$ of the neural ODE layer. The parameters $\\phi , \\theta$ and $\\mathbf { V }$ are parameterized weights for the feature extractor, neural ODE layer and FC layer, respectively. ",
+        "bbox": [
+            173,
+            265,
+            825,
+            362
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We provide motivation and design guidance for the FC layer V in Section 3.1, which attempts to separate Lyapunov-stable equilibrium points implicitly by maximizing the similarity distance between feature representations corresponding to the $L$ different classes. Experimental results demonstrate the advantages of our diversity promoting FC layer in Section 3.1 with comparisons to traditional neural ODEs without diversity promoting. ",
+        "bbox": [
+            174,
+            367,
+            825,
+            438
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, the embedded features after using diversity promoting are not guaranteed to locate near the Lyapunov-stable equilibrium points. In Section 3.2, we formulate an optimization problem to force embedding features to locate near the Lyapunov-stable equilibrium points. We introduce optimization constraints to force the Jacobian matrix of the ODE in our neural ODE layer to have eigenvalues with negative real parts at the Lyapunov-stable equilibrium points. Instead of directly imposing constraints on the eigenvalue of the matrix, which may be computationally complex especially when the matrix is large, we add constraints to the matrix elements instead. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            541
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 Maximizing the Distance between Lyapunov-Stable Equilibrium Points ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            705,
+            574
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "From Section 2, we observe that points in a small neighbourhood of a Lyapunov-stable equilibrium point is robust against adversarial perturbations. We call this neighborhood a stable neighborhood. However Lyapunov-stable equilibrium points for different classes may very well locate near each other and therefore each stable neighborhood may be very small, leading to poor adversarial defense. In this section, we propose to add a FC layer after the neural ODE layer given by (1) to avoid this scenario. The purpose of the FC layer is to map the output of the neural ODE layer to a feature vector $\\mathbf { v } _ { l }$ if the input $x$ belongs to the class $l = 1 , \\ldots , L$ . We design the FC layer so that the cosine similarities between different $\\mathbf { v } _ { l }$ ’s are minimized. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            695
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 2. Given a set of $k$ unit vectors $\\mathbf { v } _ { 1 } , \\ldots , \\mathbf { v } _ { k }$ in $\\mathbb { R } ^ { n }$ , where $n \\geq k$ , let $a ( \\mathbf { v } _ { 1 } , \\ldots , \\mathbf { v } _ { k } ) =$ $\\mathrm { m a x } _ { i \\neq j } { \\mathbf { \\Delta v } _ { i } ^ { \\mathsf { T } } } { \\mathbf { v } _ { j } }$ . Then $\\operatorname* { m i n } a ( \\mathbf { v } _ { 1 } , . . . , \\mathbf { v } _ { k } ) = 1 / ( 1 - k )$ , where the minimum is taken over all possible sets of $k$ unit vectors $\\mathbf { v } _ { 1 } , \\ldots , \\mathbf { v } _ { k }$ . ",
+        "bbox": [
+            173,
+            700,
+            825,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Corollary 1. Consider a $k \\times k$ matrix $\\mathbf { B } = [ b _ { i j } ] _ { i , j = 1 } ^ { k }$ with $b _ { i i } = 1$ and $b _ { i j } = 1 / ( 1 - k )$ , $\\forall i \\ne j$ Let the eigen decomposition of $\\mathbf { B }$ be $\\mathbf { B } = \\mathbf { U } \\pmb { \\Sigma } \\bar { \\mathbf { U } } ^ { \\dag }$ . For any $n \\geq k$ and $i = 1 , \\ldots , k$ , let $\\mathbf { v } _ { i }$ be the $i$ -th column of $\\mathbf { Q } \\mathbf { \\Sigma } ^ { \\mathrm { { X } ^ { 1 / 2 } \\bar { U } ^ { \\top } } }$ , where $\\mathbf { Q }$ is any $n \\times k$ matrix such that $\\mathbf { Q } ^ { \\intercal } \\mathbf { Q } = \\mathbf { I } _ { k }$ . Then, $a ( \\mathbf { v } _ { 1 } , \\ldots , \\mathbf { v } _ { k } ) = \\operatorname* { m a x } _ { i \\neq j } \\mathbf { v } _ { i } ^ { \\mathsf { T } } \\mathbf { v } _ { j } = { 1 } / ( 1 - k )$ . ",
+        "bbox": [
+            173,
+            746,
+            825,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Corollary 1 suggests a diversity promoting scheme to maximally separate the equilibrium points of the neural ODE layer. The FC layer is represented by an $n \\times L$ matrix $\\mathbf { V } = \\left[ \\mathbf { v } _ { 1 } , \\ldots , \\mathbf { v } _ { L } \\right]$ , where $n$ is the dimension of ${ \\mathbf z } ( T )$ , the output from the neural ODE layer. If ${ \\mathbf z } ( T )$ is generated from an input from class $l$ , it is mapped to $\\mathbf { v } _ { l }$ . By minimizing the maximum cosine similarity $a ( \\mathbf { v } _ { 1 } , \\ldots , \\mathbf { v } _ { k } ) = \\operatorname* { m a x } _ { i \\neq j } \\mathbf { v } _ { i } ^ { \\mathsf { T } } \\mathbf { v } _ { j }$ between the representations from two different classes, we ensure that the output of SODEF is robust to perturbations in the input. Corollary 1 provides a way to choose the FC layer weights $\\mathbf { V }$ . ",
+        "bbox": [
+            173,
+            814,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To validate our observations, we conduct experiments to compare the robustness of ODE net [9] and TisODE [6] with and without our proposed FC layer V, on two standard datasets: MNIST [2] and CIFAR10 [12] 2. On the MNIST dataset, all models consist of four convolutional layers and one fully-connected layer. On the CIFAR10 dataset, the networks are similar to those for MNIST except the down-sampling network is a stack of 2 ResNet blocks. In practice, the neural ODE can be solved with different numerical solvers such as the Euler method and the Runge-Kutta methods [9]. Here, we use Runge-Kutta of order 5 in our experiments. Our implementation builds on the open-source neural ODE codes.3 During training, no Gaussian noise or adversarial examples are augmented into the training set. We test the performance of our model in defending against white-box attacks FGSM [17] and PGD [13] . The parameters for different attack methods used in this paper are given in the supplementary material. From Tables 1 and 2, we observe that for both datasets, our fixed FC layer improves each network’s defense ability by a significant margin. We visualize the features before the final FC layer using t-SNE [20] in Figs. 2 and 3. We observe that with the FC layer, the features for different classes are well separated even under attacks. ",
+        "bbox": [
+            173,
+            90,
+            826,
+            285
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/0e5ba2745a4221d61b6b2b59a254f41e43e3de35524fb1614f36b886d3893236.jpg",
+        "table_caption": [
+            "Table 1: Classification accuracy $( \\% )$ on adversarial MNIST examples, where the superscript + indicates the last FC layer is fixed to be $\\mathbf { V }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Para.</td><td>ODE</td><td>ODE+</td><td>TisODE</td><td>TisODE+</td></tr><tr><td>None</td><td>-</td><td>99.6</td><td>99.7</td><td>99.5</td><td>99.7</td></tr><tr><td>FGSM</td><td>∈ = 0.3</td><td>31.4</td><td>52.8</td><td>45.9</td><td>63.5</td></tr><tr><td>PGD</td><td>∈=0.3</td><td>0.29</td><td>0.30</td><td>0.4</td><td>20.20</td></tr></table>",
+        "bbox": [
+            294,
+            327,
+            704,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/a89e2702121d6d02f24b9e928e41b754195ff4c548711b8b858664ec9ba55b89.jpg",
+        "table_caption": [
+            "Table 2: Classification accuracy $( \\% )$ on adversarial CIFAR10 examples, where the superscript + indicates the last FC layer is fixed to be $\\mathbf { V }$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Para.</td><td>ODE ODE+</td><td>TisODE</td><td>TisODE+</td></tr><tr><td>None</td><td>-</td><td>87.0 85.0</td><td>87.4</td><td>81.8</td></tr><tr><td>FGSM</td><td>∈ = 0.1</td><td>12.9 47.6</td><td>13.1</td><td>41.9</td></tr><tr><td>PGD</td><td>∈=0.1</td><td>7.8 14.7</td><td>7.4</td><td>16.2</td></tr></table>",
+        "bbox": [
+            294,
+            469,
+            704,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/2298e75b6e25d3394e76c905205ab4b066d9a6a5a3e690669fcd410610b0c475.jpg",
+        "image_caption": [
+            "Fig. 2: t-SNE visualization results on the features before the final FC layer. The input is the test set of MNIST. Left: trained with TisODE, middle: TisODE using a randomly chosen orthogonal matrix as the final FC, right: TisODE using proposed $\\mathbf { V }$ as the final FC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            589,
+            789,
+            684
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Objective Formulation and Stability ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            773,
+            464,
+            789
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we formulate an optimization framework for SODEF to force output features to locate within the stable neighborhood of Lyapunov-stable equilibrium points. We make the following assumption. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            840
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Assumption 1. The input x takes values in a compact metric space $X$ and has probability distribution $\\mu$ . The feature extractor $h _ { \\phi }$ is injective and continuous. ",
+        "bbox": [
+            174,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7a95cfded3451c7f092fca178fd0f289e9f1e03180a9b9200b577ccb2fbf9ae9.jpg",
+        "image_caption": [
+            "Fig. 3: t-SNE visualization results on the features before the final FC layer. The input is the adversarial examples of the test set of MNIST generated using FGSM method at $\\epsilon = 0 . 3$ . Left: trained with TisODE, middle: TisODE using a randomly chosen orthogonal matrix as the final FC, right: TisODE using proposed $\\mathbf { V }$ as the final FC. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            215,
+            102,
+            790,
+            179
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The above assumption is satisfied if the input $x$ (e.g., an image) resides in a bounded and closed set of a Euclidean space. We denote the pushforward measure (still a probability distribution) of $\\mu$ under the continuous feature extractor mapping $h _ { \\phi }$ as $\\nu _ { \\phi } = \\mu \\circ h _ { \\phi } ^ { - 1 }$ , where $\\circ$ denotes function composition. The conditional probability distribution for the embedding of each class $l \\in \\{ 1 , . . . , L \\}$ has compact support $E _ { l } \\subset \\mathbb { R } ^ { n }$ since $E _ { l }$ is closed and $h _ { \\phi } ( X )$ is bounded in $\\mathbb { R } ^ { n }$ . In Section 3.1, the FC layer $\\mathbf { V }$ tries to maximize the distance between $E _ { l }$ , $l = 1 , \\ldots , L$ . In this section for analysis purposes, we also assume the following. ",
+        "bbox": [
+            173,
+            284,
+            826,
+            386
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Assumption 2. We have $E _ { l } \\bigcap E _ { l ^ { \\prime } } = \\varnothing i f l \\neq l ^ { \\prime }$ , i.e., the supports of each class are pairwise disjoint. ",
+        "bbox": [
+            174,
+            388,
+            823,
+            405
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our objective function is formulated as follows, which is explained in detail in the sequel: ",
+        "bbox": [
+            176,
+            416,
+            769,
+            431
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/17dad62102c6b430df4524e5a1b5fe563dc3b301d4cb21934e0dc25966c092c6.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\underset { \\theta , \\phi } { \\operatorname* { m i n } } \\mathbb { E } _ { \\boldsymbol { \\mu } } \\ell ( { \\mathbf { V } } ^ { \\top } ( { \\mathbf { z } } ( T ) ) , y _ { i } ) } \\\\ & { \\mathrm { s . t . } \\ \\mathbb { E } _ { \\boldsymbol { \\nu } _ { \\phi } } \\| f _ { \\theta } ( { \\mathbf { z } } ( 0 ) ) \\| _ { 2 } < \\epsilon , \\ f _ { \\theta } \\in C ^ { 1 } ( \\mathbb { R } ^ { n } , \\mathbb { R } ^ { n } ) , } \\\\ & { \\quad \\quad \\quad \\mathbb { E } _ { \\boldsymbol { \\nu } _ { \\phi } } \\left[ \\nabla f _ { \\theta } ( { \\mathbf { z } } ( 0 ) ) \\right] _ { i i } < 0 , \\ \\forall i = 1 , \\ldots , n , } \\\\ & { \\quad \\quad \\mathbb { E } _ { \\boldsymbol { \\nu } _ { \\phi } } \\left[ | [ \\nabla f _ { \\theta } ( { \\mathbf { z } } ( 0 ) ) ] _ { i i } | - \\sum _ { j \\neq i } | [ \\nabla f _ { \\theta } ( { \\mathbf { z } } ( 0 ) ) ] _ { i j } | \\right] > 0 , \\ \\forall i = 1 , \\ldots , n , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            263,
+            438,
+            730,
+            541
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "$\\mathbf { z } ( 0 ) = h _ { \\phi } ( x )$ , and ${ \\mathbf z } ( T )$ is the output of (1) with input ${ \\bf z } ( 0 )$ . ",
+        "bbox": [
+            299,
+            542,
+            700,
+            559
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\ell$ is a loss function and $\\epsilon > 0$ is a positive constant. The constraints (3) to (5) force ${ \\bf z } ( 0 )$ to be near the Lyapunov-stable equilibrium points with strictly diagonally dominant derivatives. We limit the $f _ { \\theta }$ to be in $C ^ { 1 } ( \\mathbb { R } ^ { n } , \\mathbb { R } ^ { n } )$ to satisfy the condition in Theorem 1. From [21], we also know that standard multi-layer feed forward networks with as few as a single hidden layer and arbitrary bounded and non-constant activation function are universal approximators for $C ^ { 1 ^ { \\prime } } ( \\mathbb { R } ^ { n } , \\mathbb { R } ^ { n } )$ functions with respect to some performance criteria provided only that sufficiently many hidden units are available. ",
+        "bbox": [
+            173,
+            566,
+            826,
+            651
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As a comparison, TisODE [6] only includes a constraint similar to (3), which in general provides no guarantee to force ${ \\bf z } ( 0 )$ near the Lyapunov-stable equilibrium points. In the extreme case with parameters $\\theta = 0$ for $f _ { \\theta }$ such that $f _ { \\pmb { \\theta } } = 0$ , the ODE degenerates to an identity mapping. No $\\mathbf { z } ( 0 ) \\in \\mathbb { R } ^ { n }$ can now be a Lyapunov-stable equilibrium point, and no stability can therefore be guaranteed to defend against adversarial attacks even though the ODE curves still possess the nonintersecting property and steady-state constraint, which were cited as reasons for the stability of TisODE. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            753
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Instead of directly optimizing the above objective function, in our implementation, we optimize the following empirical Lagrangian with a training set $\\left\\{ \\left( x _ { k } , y _ { k } \\right) : k = 1 , { \\overset { - } { \\ldots } } , N \\right\\}$ : ",
+        "bbox": [
+            174,
+            760,
+            825,
+            790
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b4d301939d37a92afda712785de51f0bc1a3534c657b3defe6e57b3e127faa3.jpg",
+        "text": "$$\n\\begin{array} { l } { \\displaystyle \\operatorname* { m i n } _ { \\theta , \\phi } \\frac { 1 } { N } \\sum _ { k = 0 } ^ { N - 1 } \\bigg ( \\ell \\big ( \\mathbf { V } ^ { \\top } \\mathbf { z } _ { k } ( T ) , y _ { k } \\big ) + \\alpha _ { 1 } \\| f _ { \\theta } \\big ( \\mathbf { z } _ { k } ( 0 ) \\big ) \\| _ { 2 } + \\alpha _ { 2 } g _ { 1 } \\Big ( \\displaystyle \\sum _ { i = 1 } ^ { n } [ \\nabla f _ { \\theta } ( \\mathbf { z } _ { k } ( 0 ) ) ] _ { i i } \\Big ) } \\\\ { \\displaystyle \\quad \\quad + \\alpha _ { 3 } g _ { 2 } \\Big ( \\displaystyle \\sum _ { i = 1 } ^ { n } ( - | [ \\nabla f _ { \\theta } ( \\mathbf { z } _ { k } ( 0 ) ) ] _ { i i } | + \\displaystyle \\sum _ { j \\neq i } \\vert [ \\nabla f _ { \\theta } ( \\mathbf { z } _ { k } ( 0 ) ) ] _ { i j } | ) \\Big ) \\bigg ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            210,
+            796,
+            750,
+            891
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "s. t. $\\mathbf { z } _ { k } ( 0 ) = h _ { \\phi } ( x _ { k } )$ , and ${ \\mathbf z } _ { k } ( T )$ is the output of (1) with input $\\mathbf { z } _ { k } ( 0 ) , \\forall k = 1 , . . . , N$ (8) ",
+        "bbox": [
+            204,
+            892,
+            823,
+            909
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha _ { 1 } , \\alpha _ { 2 }$ and $\\alpha _ { 3 }$ are hyperparameter weights, $g _ { 1 }$ and $g _ { 2 }$ are chosen monotonically increasing functions bounded below to eliminate the unbounded impact of the two regularizers that can otherwise dominate the loss. In this paper, we set $g _ { 1 } ( \\cdot ) = g _ { 2 } ( \\cdot ) \\bar { = } \\exp ( \\cdot )$ . We call these two latter terms the SODEF regularizers. ",
+        "bbox": [
+            174,
+            92,
+            825,
+            147
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Suppose for each class $l = 1 , \\ldots , L$ , the embedding feature set $E _ { l } = \\{ \\mathbf { z } _ { 1 } ^ { ( l ) } , \\dots , \\mathbf { z } _ { k } ^ { ( l ) } \\}$ z(l)k } is finite. For each $i = 1 , \\ldots , k$ , let $\\mathbf { A } _ { i } \\in \\mathbb { R } ^ { n \\times n }$ be strictly diagonally dominant matrix with every main diagonal entry be negative such that the eigenvalues for $\\mathbf { A } _ { i }$ all have negative real part. From Theorem 3, each $\\mathbf { A } _ { i }$ is non-singular and every eigenvalue of $\\mathbf { A } _ { i }$ has negative real part. Therefore, from Theorem 2 and Lemma 1, there exists a function $f _ { \\theta }$ such that all $\\mathbf { z } _ { i } ^ { ( l ) }$ are Lyapunov-stable equilibrium points with corresponding first derivative $\\nabla f _ { \\pmb \\theta } ( \\mathbf z _ { i } ^ { ( l ) } ) = \\mathbf { A } _ { i }$ . This shows that if there exist only finite representation points for each class, we can find a function $f _ { \\theta }$ such that all inputs to the neural ODE layer are Lyapunov-stable equilibrium points for $f _ { \\theta }$ and ",
+        "bbox": [
+            173,
+            154,
+            826,
+            277
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3bbe106347beefc10dd2696ad5328d308d46fd72b887ecee504a3bbcb4dd165d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbb { E } _ { \\boldsymbol \\nu _ { \\phi } } \\left\\| f _ { \\boldsymbol \\theta } ( \\mathbf { z } ( 0 ) ) \\right\\| _ { 2 } = 0 , } \\\\ & { \\mathbb { E } _ { \\boldsymbol \\nu _ { \\phi } } \\left[ \\nabla f _ { \\boldsymbol \\theta } ( \\mathbf { z } ( 0 ) ) \\right] _ { i i } < 0 , \\forall i = 1 , \\ldots , n , } \\\\ & { \\mathbb { E } _ { \\boldsymbol \\nu _ { \\phi } } \\left[ | [ \\nabla f _ { \\boldsymbol \\theta } ( \\mathbf { z } ( 0 ) ) ] _ { i i } | - \\sum _ { j \\neq i } \\vert [ \\nabla f _ { \\boldsymbol \\theta } ( \\mathbf { z } ( 0 ) ) ] _ { i j } \\vert \\right] > 0 , \\forall i = 1 , \\ldots , n . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            284,
+            679,
+            353
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "If the input space $X$ has infinite cardinality, then an injective and continuous feature extractor $h _ { \\phi }$ results in a $\\nu _ { \\phi }$ with non-finite support, i.e., at least one $E _ { l }$ , $l = 1 , \\ldots , L$ , is infinite. It is not obvious whether we can obtain a $f _ { \\theta }$ where every point in $\\textstyle E = \\bigcup _ { l } E _ { l }$ is a stable equilibrium point. The following result gives a negative answer if $\\nu _ { \\phi }$ is a continuous measure (i.e., absolutely continuous with respect to (w.r.t.) Lebesgue measure) on some subset. ",
+        "bbox": [
+            174,
+            359,
+            825,
+            429
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3. If the restriction of $\\nu _ { \\phi }$ to some open set $E ^ { \\prime } \\subset E$ is a continuous measure, there is no continuous function fθ such that for $\\nu _ { \\phi }$ -almost surely all $\\mathbf { z } \\in E$ , $f _ { \\pmb \\theta } ( \\mathbf z ) = 0$ and all the eigenvalues of $\\nabla f _ { \\boldsymbol { \\theta } } ( \\mathbf { z } )$ have negative real parts. In other words, there is no continuous function fθ such that almost surely all $\\mathbf { z }$ in $E$ are Lyapunov-stable equilibrium points. ",
+        "bbox": [
+            173,
+            433,
+            823,
+            488
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lemma 3 indicates that it is too much to hope for all points in $E$ to be Lyapunov-stable equilibrium points. In the following, we relax this requirement and show that under mild conditions, for all $\\epsilon > 0$ , we can find a continuous function $f _ { \\theta }$ with finitely many stable equilibrium points such that conditions (b) and (c) above hold and condition (a) is replaced by $\\mathbb { E } _ { \\boldsymbol { \\nu } _ { \\phi } } \\bar { \\| } f _ { \\theta } ( \\mathbf { z } ( 0 ) ) \\| _ { 2 } ^ { - } < \\epsilon$ . This motivates the optimization constraints in (3) to (5). ",
+        "bbox": [
+            173,
+            497,
+            825,
+            568
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Theorem 4. Suppose Assumptions $I$ and 2. If $\\nu _ { \\phi }$ is not a continuous uniform measure on $E _ { l }$ for each $l = 1 , \\ldots , L$ , then the following holds: 1) The function space satisfying the constraints in (3) to (5) is non-empty for all $\\epsilon > 0$ . 2) If additionally the restriction of $\\nu _ { \\phi }$ to any open set $O \\subset E _ { l }$ is not a continuous uniform measure, there exist functions in this space such that each support $E _ { l }$ contains at least one Lyapunov-stable equilibrium point. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            641
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            659,
+            312,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the robustness of SODEF under adversarial attacks with different attack parameters. We conduct experiments to compare the robustness of ODE net [9] and TisODE net [6] on three standard datasets: MNIST [2], CIFAR10 and CIFAR100 [3]. Since SODEF is compatible with many defense methods, it can be applied to any neural network’s final regressor layer to enhance its stability against adversarial attacks. Our experiment codes are provided in https://github.com/KANGQIYU/SODEF. ",
+        "bbox": [
+            173,
+            689,
+            825,
+            773
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Setup",
+        "text_level": 1,
+        "bbox": [
+            174,
+            789,
+            253,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We use open-source pre-trained models that achieve the top accuracy on each dataset as the feature extractor $h _ { \\phi }$ . Specifically for simple MNIST task, we use the ResNet18 model provided in Pytorch. We use the model provided by [22], which obtains nearly $8 8 \\%$ clean accuracy on CIFAR100 using EfficientNet [23] and the model provided by [24], which has nearly $9 5 \\%$ clean accuracy on CIFAR10. In the neural ODE layer, $f _ { \\theta }$ consists of 2 FC layers. During the trainings of SODEF (except in the experiment included in Section 4.2), we train the neural network with the fixed FC introduced in Section 3.1. In the first 30 epochs, we fixed $f _ { \\theta }$ to let the feature extractor $h _ { \\phi }$ learn a feature representation with only the cross-entropy loss $\\ell$ , and in the remaining 120 epochs, we release $h _ { \\phi }$ to further train $f _ { \\theta }$ using (7) with $\\alpha _ { 1 } = 1$ and $\\alpha _ { 2 } = \\alpha _ { 3 } = 0 . 0 5$ . For CIFAR10 and CIFAR100, the pixel values are normalized by $( x - \\mu ) / \\sigma$ where $\\mu = [ 0 . 4 9 1 4 , 0 . 4 8 2 2 , 0 . 4 4 6 5 ]$ and $\\sigma = [ 0 . 2 0 2 3 , 0 . 1 9 9 4 , 0 . 2 0 1 0 ] ^ { 4 }$ . To show that our SODEF is compatible with many defense methods and can be applied to any neural network’s final regression layer, we conduct an experiment where we use a recently proposed robust network TRADES [25] as the feature extractor in our SODEF. The pretrained model is provided here 5, and we choose the model with architecture \"WRN- $3 4 \\mathrm { - } 1 0 \"$ to conduct our experiments. Besides the two vanilla white-box attacks FGSM and PGD as metioned in Section 3.1, we also include a strong ensemble attack AutoAttack [26], which sequentially performs attack using all of the following four individual attacks: three white-box attacks APGDCE, APGDTDLR and FABT[27], and one black-box Square attack [28]. We refer the reader to the the supplementary material for more details of the attacks used in this paper, where, in additional, more experiments are included. ",
+        "bbox": [
+            174,
+            814,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            90,
+            825,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Compatibility of SODEF ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            273,
+            385,
+            287
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Adversarial training (AT) is one of the most effective strategies for defending adversarial attacks. TRADES [25] is one of the adversarial training defense methods with combinations of tricks of warmup, early stopping, weight decay, batch size and other hyper parameter settings. In this experiment we fix the pretained TRADES model (except the final FC layer (size $6 4 0 \\mathrm { x } 1 0 )$ ) as our feature extractor $h _ { \\phi }$ . We then append our (trainable) SODEF with integration time $T = 5$ to the output of the feature extractor. To evaluate model robustness, we use AutoAttack and attack the models using both the $\\mathcal { L } _ { 2 }$ norm $\\epsilon = 0 . 5$ ) and $\\mathcal { L } _ { \\infty }$ norm $( \\epsilon = 8 / 2 5 5 )$ ). The results are shown in Table 3. We clearly observe that our SODEF can enhance TRADES’s robustness under all the four individual attacks and the strongest ensemble AutoAttack. For the strong $\\mathcal { L } _ { 2 }$ AutoAttack, our SODEF have improved the model robustness from $5 9 . 4 2 \\%$ to $6 7 . 7 5 \\%$ . Our experiment show that SODEF can be applied to many defense models’ regression layer to enhance their stability against attacks. ",
+        "bbox": [
+            173,
+            297,
+            825,
+            450
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/72bb27c9394cce1e70f688ac4fde16bcef7caea32833005fb4cf6ed7459bf413.jpg",
+        "table_caption": [
+            "Table 3: Classification accuracy $( \\% )$ using TRADES (w/ and w/o SODEF) under AutoAttack on adversarial CIFAR10 examples with $\\mathcal { L } _ { 2 }$ norm $\\epsilon = 0 . 5 )$ and $\\mathcal { L } _ { \\infty }$ norm $( \\epsilon = 8 / 2 5 5 )$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"4\">Attack /ModelTRADES LTRADES+SODEF LTRADES L2TRADES+SODEF L2</td></tr><tr><td>Clean</td><td>85.48</td><td>85.18</td><td>85.48 85.18</td></tr><tr><td>APGDcE</td><td>56.08</td><td>70.90</td><td>61.74 74.35</td></tr><tr><td>APGDDLR</td><td>53.70</td><td>64.15</td><td>59.22 68.55</td></tr><tr><td>FABT</td><td>54.18</td><td>82.92</td><td>60.31 83.15</td></tr><tr><td>Square</td><td>59.12</td><td>62.21</td><td>72.65 76.02</td></tr><tr><td>AutoAttack</td><td>53.69</td><td>57.76</td><td>59.42 67.75</td></tr></table>",
+        "bbox": [
+            235,
+            492,
+            761,
+            597
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 Influence of Integration Time $T$ ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            431,
+            642
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "From the discussion after Theorems 1 and 2, we know if the malicious perturbations around the ODE input Lyapunov-stable equilibrium point ${ \\bf z } ( 0 )$ is small, then the output ${ \\mathbf z } ( T )$ for large enough $T$ will not be affected significantly by the perturbation: $\\| \\tilde { { \\mathbf z } } ( t ) - { \\mathbf z } ( 0 ) \\| _ { 2 } \\dot { \\to } 0$ as $t \\to \\infty$ . Consequently, the succeeding network layers after the neural ODE layer can still perform well without being affected by the input perturbation. In this section, we test the influence of the SODEF integration time $T$ using CIFAR100. We use the model EfficientNet provided by [23] as $h _ { \\phi }$ (Note, unlike Section 4.2, $h _ { \\phi }$ is trainable in this experiments). We use AutoAttack with $\\mathcal { L } _ { 2 }$ norm $\\epsilon = 0 . 5$ ). We observe that for all the four individual attacks and the strongest ensemble AutoAttack, SODEF performs generally better for large integration time $T$ . We also test larger integration time $T > 1 0$ , but do not see any obvious improvements. ",
+        "bbox": [
+            173,
+            652,
+            825,
+            791
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.4 Performance Comparison Under AutoAttack ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            808,
+            526,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For a comparison, we provide the results of applying AutoAttack to other baseline models mentioned in the paper. We set the same integration time for ODE, TisODE and SODEF. We observe that for the ",
+        "bbox": [
+            176,
+            833,
+            823,
+            861
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/221ec33a77e3f820b4d08617a24a5d36fff411ef1966cd3186ed841be8ed6a35.jpg",
+        "table_caption": [
+            "Table 4: Classification accuracy $( \\% )$ under AutoAttack on adversarial CIFAR100 examples with $\\mathcal { L } _ { 2 }$ norm, $\\epsilon = 0 . 5$ and different integration time $T$ for SODEF. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack/T</td><td>1</td><td>3</td><td>5</td><td>6</td><td>7</td><td>8</td><td>9</td><td>10</td></tr><tr><td>Clean</td><td>88.00</td><td>88.12</td><td>88.15</td><td>88.00</td><td>87.92</td><td>88.00</td><td>88.05</td><td>88.10</td></tr><tr><td>APGDcE</td><td>17.20</td><td>21.33</td><td>21.05</td><td>23.67</td><td>69.67</td><td>85.33</td><td>87.10</td><td>86.88</td></tr><tr><td>APGDLR</td><td>21.02</td><td>21.00</td><td>22.00</td><td>26.00</td><td>63.30</td><td>86.90</td><td>86.20</td><td>86.54</td></tr><tr><td>FABT</td><td>86.33</td><td>85.10</td><td>86.36</td><td>87.70</td><td>87.67</td><td>86.55</td><td>86.22</td><td>85.93</td></tr><tr><td>Square</td><td>84.67</td><td>86.22</td><td>87.05</td><td>87.20</td><td>86.90</td><td>86.33</td><td>87.05</td><td>86.75</td></tr><tr><td>AutoAttack</td><td>2.00</td><td>3.53</td><td>4.87</td><td>4.33</td><td>30.66</td><td>78.80</td><td>78.97</td><td>79.10</td></tr></table>",
+        "bbox": [
+            243,
+            116,
+            756,
+            220
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "strongest AutoAttack, our SODEF outperforms the other baseline models by a significant margin. In this case, SODEF achieves $7 9 . 1 0 \\%$ accuracy while other models only get less than $3 \\%$ accuracy. ",
+        "bbox": [
+            173,
+            246,
+            825,
+            275
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/22e650d3db41d1dda7808ccc6f63fd084fecc876451293b266e6f81cd54c2ab8.jpg",
+        "table_caption": [
+            "Table 5: Classification accuracy $( \\% )$ under AutoAttack on adversarial CIFAR100 examples with $\\mathcal { L } _ { 2 }$ norm, $\\epsilon = 0 . 5$ and $T = 1 0$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack/Model</td><td>NoODE</td><td>ODE</td><td>TisODE</td><td>SODEF</td></tr><tr><td>Clean</td><td>88.00</td><td>87.90</td><td>88.00</td><td>88.10</td></tr><tr><td>APGDCE</td><td>23.30</td><td>6.75</td><td>14.32</td><td>86.88</td></tr><tr><td></td><td>7.33</td><td>22.00</td><td>24.20</td><td>86.54</td></tr><tr><td>FAB</td><td>79.30</td><td>78.67</td><td>77.16</td><td>85.93</td></tr><tr><td>Square</td><td>84.52</td><td>85.67</td><td>86.32</td><td>86.75</td></tr><tr><td>AutoAttack</td><td>0.00</td><td>1.33</td><td>4.06</td><td>79.10</td></tr></table>",
+        "bbox": [
+            313,
+            314,
+            683,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 Performance Under PGD and FGSM Attacks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            527,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "White-box adversaries have knowledge of the classifier models, including training data, model architectures and parameters. We test the performance of our model in defending against the whitebox attacks, PGD and FGSM. We set $T = 5$ as the integration time for the neural ODE layer. The parameters for different attack methods used are given in the supplementary material. The subsequent experiments use these settings by default, unless otherwise stated. ",
+        "bbox": [
+            173,
+            467,
+            826,
+            536
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/08b150433d3576a1490d72d07775e57a65e7a73c041808639a034b1d4b92953f.jpg",
+        "table_caption": [
+            "Table 6: Classification accuracy $( \\% )$ on adversarial MNIST examples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Para.</td><td>no ode</td><td>ODE</td><td>TisODE</td><td>SODEF</td></tr><tr><td>None</td><td>-</td><td>99.45</td><td>99.42</td><td>99.43</td><td>99.44</td></tr><tr><td>FGSM</td><td>∈=0.3</td><td>10.03</td><td>29.6</td><td>36.70</td><td>63.36</td></tr><tr><td>PGD</td><td>∈= 0.3</td><td>0.31</td><td>1.56</td><td>1.82</td><td>45.25</td></tr></table>",
+        "bbox": [
+            310,
+            564,
+            684,
+            631
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The classification results on MNIST are shown in Table 6. We observe that while maintaining the state-of-the-art accuracy on normal images, SODEF improves the adversarial robustness as compared to the other two methods. For the most effective attack in this experiment, i.e., PGD attack, SODEF shows a $4 5 . 2 5 \\% - 1 . 5 6 \\% = 4 3 . 6 9 \\%$ improvement over ODE and a $4 5 . 2 5 \\% - 1 . 2 3 \\% = 4 4 . 0 2 \\%$ improvement over TisODE. ",
+        "bbox": [
+            173,
+            643,
+            826,
+            713
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c17b7a629d8b072e122c9a92c1b4da9ce1ce3169872ef2f345d05c365d9d807.jpg",
+        "table_caption": [
+            "Table 7: Classification accuracy $( \\% )$ on adversarial CIFAR10 examples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Para.</td><td>no ode</td><td>ODE</td><td>TisODE</td><td>SODEF</td></tr><tr><td>None</td><td>-</td><td>95.2</td><td>94.9</td><td>95.1</td><td>95.0</td></tr><tr><td>FGSM</td><td>∈=0.1</td><td>47.31</td><td>45.23</td><td>43.28</td><td>68.05</td></tr><tr><td>PGD</td><td>∈=0.1</td><td>3.09</td><td>3.21</td><td>3.80</td><td>55.59</td></tr></table>",
+        "bbox": [
+            310,
+            741,
+            686,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For CIFAR-10, we see from Table 7 that SODEF maintains high accuracy on normal examples and makes the best predictions under adversarial attacks. In particular, SODEF achieves an absolute percentage point improvement over ODE net up to $5 2 . 3 8 \\%$ and over TisODE up to $5 2 . 5 4 \\%$ for PGD attack. ",
+        "bbox": [
+            173,
+            820,
+            826,
+            877
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For CIFAR-100, the results in the supplementary material shows that the most effective attack causes the classification accuracy to drop relatively by $\\begin{array} { r } { 7 4 . 6 \\% = \\frac { 8 8 . 0 - 2 2 . 3 5 } { 8 8 . 0 } } \\end{array}$ 88.0−22.35 for SODEF and by $\\begin{array} { r } { 9 7 . 3 \\% = \\frac { 8 8 . 3 - 2 . 3 9 } { 8 8 . 3 } } \\end{array}$ for vanilla EfficientNet, which is pre-trained on ImageNet to obtain a top clean accuracy. Neither ODE net nor TisODE net can improve the classification accuracy under PGD attack by a big margin, e.g. TisODE net only improves the classification accuracy from $2 . 3 9 \\%$ to $3 . 4 4 \\%$ , while SODEF still shows clear defense capability in this scenario. ",
+        "bbox": [
+            173,
+            882,
+            825,
+            914
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            89,
+            825,
+            147
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6 Ablation Studies ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            165,
+            328,
+            179
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The impact of the ODE with and without the SODEF regularizers in (7) has been presented in the above comparisons between SODEF and ODE. In this section, we show the necessity of diversity promoting using the FC introduced in Section 3.1 and conduct transferability study. ",
+        "bbox": [
+            176,
+            190,
+            823,
+            233
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6.1 Impact of Diversity Promotion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            248,
+            437,
+            263
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/d06c699467442a5ac71624b7467860c1c3db93486d0d6f42604ef4497a5112f5.jpg",
+        "table_caption": [
+            "Table 8: Classification accuracy $( \\% )$ on adversarial MNIST examples, where the superscript indicates the last FC layer is not fixed to be $\\mathbf { V }$ and is set to be a trainable layer. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Attack</td><td>Para.</td><td>SODEF</td><td>SODEF-</td></tr><tr><td>None</td><td>-</td><td>95.0</td><td>95.1</td></tr><tr><td>FGSM</td><td>∈=0.1</td><td>63.36</td><td>51.6</td></tr><tr><td>PGD</td><td>∈=0.1</td><td>45.25</td><td>34.9</td></tr></table>",
+        "bbox": [
+            352,
+            316,
+            643,
+            402
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Table 8 shows the difference of the defense performance when fixing the final FC be $\\mathbf { V }$ or setting it to a trainable linear layer. It can be seen that having diversity control improves the robustness. One possible reason for this phenomenon given in Section 3 is that diversity promotion with a fixed designed FC attempts to make the embedding feature support $E _ { l }$ of each class $l$ disjoint to each other and therefore the Lyapunov-stable equilibrium points for each $E _ { l }$ are well separated. ",
+        "bbox": [
+            174,
+            417,
+            826,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6.2 Transferability Study ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            503,
+            374,
+            518
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Transferability study is carried out on CIFAR-10, where the adversarial examples are generated using FGSM and PGD attacks using ResNet18 without any ODEs. The classification accuracy drops from $6 8 . 0 5 \\%$ to $5 9 \\%$ for FGSM with $\\epsilon = 0 . 3$ , and from $5 5 . 5 9 \\%$ to $3 4 \\%$ for PGD with $\\epsilon = 0 . 1$ . One possible reason for this phenomenon is that ODEs have obfuscated gradient masking effect as discussed in [15], and a transfer attack may deteriorate the defense effect. However, as we observe from Table 7, even with a transfer attack on SODEF, it still performs better than other ODEs without transfer attacks. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusion ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            646,
+            299,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we have developed a new neural ODE network, SODEF, to suppress input perturbations. SODEF is compatible with any existing neural networks and can thus be appended to the state-of-theart networks to increase their robustness to adversarial attacks. We demonstrated empirically and theoretically that the robustness of SODEF mainly derives from its stability and proposed a training method that imposes constraints to ensure all eigenvalues of the Jacobian matrix of the neural ODE layer have negative real parts. When each classification class converges to its own equilibrium points, we showed that the last FC layer can be designed in such a way that the distance between the stable equilibrium points is maximized, which further improves the network’s robustness. The effectiveness of SODEF has been verified under several popular while-box attacks. ",
+        "bbox": [
+            174,
+            678,
+            825,
+            803
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgments and Disclosure of Funding ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            553,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This research is supported in part by A\\*STAR under its RIE2020 Advanced Manufacturing and Engineering (AME) Industry Alignment Fund – Pre Positioning (IAF-PP) (Grant No. A19D6a0053) and the RIE2020 Industry Alignment Fund – Industry Collaboration Projects (IAF-ICP) Funding Initiative, as well as cash and in-kind contribution from the industry partner(s). The computational work for this article was partially performed on resources of the National Supercomputing Centre, Singapore (https://www.nscc.sg). ",
+        "bbox": [
+            176,
+            854,
+            825,
+            911
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Broader Impact ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            310,
+            156
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Our work, which contributes to more robust DNNs, is supposed to mitigate the threat of adversarial attacks. However, on the hand, the reliable deployment of DNNs in automation of tasks will potentially bring mass-scale unemployment and social unrest. As DNNs become more robust and more tasks, especially those whose failures will bring high risks to human lives or large property losses under adversarial attacks, fall into the automatic task category, massive jobs could disappear. ",
+        "bbox": [
+            174,
+            171,
+            825,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            261,
+            266,
+            277
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "[1] A. Krizhevsky, I. Sutskever, and G. E. Hinton, “ImageNet classification with deep convolutional neural networks,” in Proc. Advances Neural Inf. Process. Syst., 2012.   \n[2] Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner, “Gradient-based learning applied to document recognition,” Proceedings of the IEEE, vol. 86, no. 11, pp. 2278–2324, Nov. 1998.   \n[3] G. Hinton, L. Deng, D. Yu, G. E. Dahl, A. Mohamed, N. Jaitly, A. Senior, V. Vanhoucke, P. Nguyen, T. N. Sainath, and B. Kingsbury, “Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups,” IEEE Signal Process. Mag., vol. 29, no. 6, pp. 82–97, Nov. 2012.   \n[4] D. Andor, C. Alberti, D. Weiss, A. Severyn, A. Presta, K. Ganchev, S. Petrov, and M. Collins, “Globally normalized transition-based neural networks,” in Proc. Annu. Meeting Assoc, Comput. Linguistics, 2016.   \n[5] C. Szegedy, W. Zaremba, I. Sutskever, J. Bruna, D. Erhan, I. Goodfellow, and R. Fergus, “Intriguing properties of neural networks,” in Proc. Int. Conf. Learning Representations, 2013.   \n[6] H. Yan, J. Du, V. Y. Tan, and J. Feng, “On robustness of neural ordinary differential equations,” in Proc. Advances Neural Inf. Process. Syst., 2018, pp. 1–13.   \n[7] E. Haber and L. Ruthotto, “Stable architectures for deep neural networks,” Inverse Problems, vol. 34, no. 1, pp. 1–23, Dec. 2017.   \n[8] X. Liu, S. Si, Q. Cao, S. Kumar, and C.-J. Hsieh, “How does noise help robustness? Explanation and exploration under the neural sde framework,” in Proc. Conf. Comput. Vision Pattern Recognition, 2020, pp. 282–290.   \n[9] R. T. Chen, Y. Rubanova, J. Bettencourt, and D. Duvenaud, “Neural ordinary differential equations,” arXiv preprint arXiv:1806.07366, 2018.   \n[10] C.-T. Chen and B. Shafai, Linear system theory and design. New York: Oxford university press New York, 1999.   \n[11] Y. LeCun, C. Corte, and C. Burges, “MNIST handwritten digit database,” ATT Labs [Online]. Available: http://yann.lecun.com/exdb/mnist, vol. 2, 2010, (Last accessed: Dec 1, 2020).   \n[12] A. Krizhevsky and G. Hinton, “Learning multiple layers of features from tiny images,” Master’s thesis, Department of Computer Science, University of Toronto, 2009.   \n[13] A. M ˛adry, A. Makelov, L. Schmidt, D. Tsipras, and A. Vladu, “Towards deep learning models resistant to adversarial attacks,” in Proc. Int. Conf. Learning Representations, 2018.   \n[14] E. Haber and L. Ruthotto, “Stable architectures for deep neural networks,” Inverse Problems, vol. 34, no. 1, 2018.   \n[15] Y. Huang, Y. Yu, H. Zhang, Y. Ma, and Y. Yao, “Adversarial robustness of stabilized neuralodes might be from obfuscated gradients,” arXiv preprint arXiv:2009.13145, 2020.   \n[16] L. Mingjie, H. Lingshen, and L. Zhouchen, “Implicit Euler skip connections: Enhancing adversarial robustness via numerical stability,” in Proc. Int. Conf. Machine Learning, 2020.   \n[17] I. J. Goodfellow, J. Shlens, and C. Szegedy, “Explaining and harnessing adversarial examples,” in Proc. Int. Conf. Learning Representations, 2015.   \n[18] D. Arrowsmith and C. M. Place, Dynamical systems: differential equations, maps, and chaotic behaviour. London: CRC Press, 1992.   \n[19] R. A. Horn and C. R. Johnson, Matrix analysis. New York: Cambridge university press, 2012.   \n[20] L. Van der Maaten and G. Hinton, “Visualizing data using t-sne,” J. Mach. Learning Res., vol. 9, no. 11, pp. 2580–2605, Nov. 2008.   \n[21] K. Hornik, “Approximation capabilities of multilayer feedforward networks,” Neural Networks, vol. 4, no. 2, pp. 251–257, Oct. 1991.   \n[22] Y. Luo, Y. Wong, S. M. Kankanhalli, and Q. Zhao, “Direction concentration learning: Enhancing congruency in machine learning,” IEEE Trans. Pattern Anal. Mach. Intell., vol. 43, no. 1, pp. 1928 – 1946, Jun. 2021.   \n[23] M. Tan and Q. Le, “Efficientnet: Rethinking model scaling for convolutional neural networks,” in Proc. Int. Conf. Mach. Learning, 2019, pp. 6105–6114.   \n[24] Github pytorch-cifar repository. Accessed: May 1, 2021. [Online]. Available: https: //github.com/kuangliu/pytorch-cifar   \n[25] T. Pang, X. Yang, Y. Dong, H. Su, and J. Zhu, “Bag of tricks for adversarial training,” in Proc. Int. Conf. Learning Representations, 2021.   \n[26] F. Croce and M. Hein, “Reliable evaluation of adversarial robustness with an ensemble of diverse parameter-free attacks,” in Proc. Int. Conf. Mach. Learning, 2020, pp. 2206–2216.   \n[27] ——, “Minimally distorted adversarial examples with a fast adaptive boundary attack,” in Proc. Int. Conf. Mach. Learning, 2020, pp. 2196–2205.   \n[28] M. Andriushchenko, F. Croce, N. Flammarion, and M. Hein, “Square attack: a query-efficient black-box adversarial attack via random search,” in Proc. European Conf. Comput. Vision. Springer, 2020, pp. 484–501. ",
+        "bbox": [
+            178,
+            280,
+            826,
+            914
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            87,
+            830,
+            590
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            254,
+            628
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            638,
+            339,
+            652
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [Yes]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            657,
+            825,
+            748
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            753,
+            493,
+            767
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] . See Assumption 1 and Assumption 2   \n(b) Did you include complete proofs of all theoretical results? [Yes] . See supplementary material. ",
+        "bbox": [
+            238,
+            771,
+            825,
+            830
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            834,
+            393,
+            849
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] .   \n(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] . See Sections 3.1 and 4   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [No] Having ODE blocks in our model, it would be too computationally expensive to repeat experiments for many times. We repeated each experiment for 2-3 times and we observe the deviation of the classification results is within $\\pm 3 \\%$ , though these experimental repetitions are not enough to construct error bars.   \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 3.1. ",
+        "bbox": [
+            238,
+            853,
+            825,
+            911
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            235,
+            92,
+            825,
+            205
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            214,
+            209,
+            823,
+            224
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes] See Sections 3.1 and 4 for the open-source models we have used from GitHub.   \n(b) Did you mention the license of the assets? [No] . Please see the licenses given in the GitHub link.   \n(c) Did you include any new assets either in the supplemental material or as a URL? [No] No new assets.   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [Yes] MNIST, CIFAR-10 and CIFAR-100 are all open-source datasets.   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [No] There is no identifiable information or offensive content in the datasets. ",
+        "bbox": [
+            238,
+            228,
+            825,
+            390
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            395,
+            705,
+            410
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            412,
+            825,
+            502
+        ],
+        "page_idx": 12
+    }
+]

parse/train/B1g5sA4twr/B1g5sA4twr.md

@@ -0,0 +1,442 @@
+# DEEP DOUBLE DESCENT: WHERE BIGGER MODELS AND MORE DATA HURT
+
+Preetum Nakkiran∗ Harvard University
+
+Gal Kaplun† Harvard University
+
+Yamini Bansal† Harvard University
+
+Tristan Yang Harvard University
+
+Boaz Barak Harvard University
+
+Ilya Sutskever OpenAI
+
+# ABSTRACT
+
+We show that a variety of modern deep learning tasks exhibit a “double-descent” phenomenon where, as we increase model size, performance first gets worse and then gets better. Moreover, we show that double descent occurs not just as a function of model size, but also as a function of the number of training epochs. We unify the above phenomena by defining a new complexity measure we call the effective model complexity and conjecture a generalized double descent with respect to this measure. Furthermore, our notion of model complexity allows us to identify certain regimes where increasing (even quadrupling) the number of train samples actually hurts test performance.
+
+# 1 INTRODUCTION
+
+![](images/c4a62cbdb7fbeb5034e735ae46b0639e991da1ee0ce7c9ca2623db843dff96c3.jpg)  
+Figure 1: Left: Train and test error as a function of model size, for ResNet18s of varying width on CIFAR-10 with $15 \%$ label noise. Right: Test error, shown for varying train epochs. All models trained using Adam for 4K epochs. The largest model (width 64) corresponds to standard ResNet18.
+
+The bias-variance trade-off is a fundamental concept in classical statistical learning theory (e.g., Hastie et al. (2005)). The idea is that models of higher complexity have lower bias but higher variance. According to this theory, once model complexity passes a certain threshold, models “overfit” with the variance term dominating the test error, and hence from this point onward, increasing model complexity will only decrease performance (i.e., increase test error). Hence conventional wisdom in classical statistics is that, once we pass a certain threshold, “larger models are worse.”
+
+However, modern neural networks exhibit no such phenomenon. Such networks have millions of parameters, more than enough to fit even random labels (Zhang et al. (2016)), and yet they perform much better on many tasks than smaller models. Indeed, conventional wisdom among practitioners is that “larger models are better’’ (Krizhevsky et al. (2012), Huang et al. (2018), Szegedy et al.
+
+![](images/08ba3538956dd39cc42384ec2f1e07bf08c6fc91c71879c2a0bb15a89998beb1.jpg)  
+Figure 2: Left: Test error as a function of model size and train epochs. The horizontal line corresponds to model-wise double descent–varying model size while training for as long as possible. The vertical line corresponds to epoch-wise double descent, with test error undergoing double-descent as train time increases. Right Train error of the corresponding models. All models are Resnet18s trained on CIFAR-10 with $15 \%$ label noise, data-augmentation, and Adam for up to 4K epochs.
+
+(2015), Radford et al. (2019)). The effect of training time on test performance is also up for debate. In some settings, “early stopping” improves test performance, while in other settings training neural networks to zero training error only improves performance. Finally, if there is one thing both classical statisticians and deep learning practitioners agree on is “more data is always better”.
+
+In this paper, we present empirical evidence that both reconcile and challenge some of the above “conventional wisdoms.” We show that many deep learning settings have two different regimes. In the under-parameterized regime, where the model complexity is small compared to the number of samples, the test error as a function of model complexity follows the U-like behavior predicted by the classical bias/variance tradeoff. However, once model complexity is sufficiently large to interpolate i.e., achieve (close to) zero training error, then increasing complexity only decreases test error, following the modern intuition of “bigger models are better”. Similar behavior was previously observed in Opper (1995; 2001), Advani & Saxe (2017), Spigler et al. (2018), and Geiger et al. (2019b). This phenomenon was first postulated in generality by Belkin et al. (2018) who named it “double descent”, and demonstrated it for decision trees, random features, and 2-layer neural networks with $\ell _ { 2 }$ loss, on a variety of learning tasks including MNIST and CIFAR-10.
+
+Main contributions. We show that double descent is a robust phenomenon that occurs in a variety of tasks, architectures, and optimization methods (see Figure 1 and Section 5; our experiments are summarized in Table A). Moreover, we propose a much more general notion of “double descent” that goes beyond varying the number of parameters. We define the effective model complexity (EMC) of a training procedure as the maximum number of samples on which it can achieve close to zero training error. The EMC depends not just on the data distribution and the architecture of the classifier but also on the training procedure—and in particular increasing training time will increase the EMC.
+
+We hypothesize that for many natural models and learning algorithms, double descent occurs as a function of the EMC. Indeed we observe “epoch-wise double descent” when we keep the model fixed and increase the training time, with performance following a classical U-like curve in the underfitting stage (when the EMC is smaller than the number of samples) and then improving with training time once the EMC is sufficiently larger than the number of samples (see Figure 2). As a corollary, early stopping only helps in the relatively narrow parameter regime of critically parameterized models.
+
+Sample non-monotonicity. Finally, our results shed light on test performance as a function of the number of train samples. Since the test error peaks around the point where EMC matches the number of samples (the transition from the under- to over-parameterization), increasing the number of samples has the effect of shifting this peak to the right. While in most settings increasing the number of samples decreases error, this shifting effect can sometimes result in a setting where more data is worse! For example, Figure 3 demonstrates cases in which increasing the number of samples by a factor of 4.5 results in worse test performance.
+
+![](images/5c137bc12053fdd4c20394058fe9f6b4430c5f548f5d67abd01978eb2d8cc676.jpg)  
+Figure 3: Test loss (per-token perplexity) as a function of Transformer model size (embedding dimension $d _ { m o d e l . }$ ) on language translation (IWSLT‘14 German-to-English). The curve for $1 8 \mathrm { k }$ samples is generally lower than the one for $4 \mathrm { k }$ samples, but also shifted to the right, since fitting 18k samples requires a larger model. Thus, for some models, the performance for $1 8 \mathrm { k }$ samples is worse than for $4 \mathrm { k \Omega }$ samples.
+
+# 2 OUR RESULTS
+
+To state our hypothesis more precisely, we define the notion of effective model complexity. We define a training procedure $\tau$ to be any procedure that takes as input a set $S = \{ ( x _ { 1 } , y _ { 1 } ) , \dots , ( x _ { n } , y _ { n } ) \}$ of labeled training samples and outputs a classifier $\mathcal { T } ( S )$ mapping data to labels. We define the effective model complexity of $\tau$ (w.r.t. distribution $\mathcal { D }$ ) to be the maximum number of samples $n$ on which $\tau$ achieves on average $\approx 0$ training error.
+
+Definition 1 (Effective Model Complexity) The Effective Model Complexity (EMC) of a training procedure $\tau$ , with respect to distribution $\mathcal { D }$ and parameter $\epsilon > 0$ , is defined as:
+
+$$
+\operatorname { E M C } _ { { \mathscr { D } } , \epsilon } ( { \mathscr { T } } ) : = \operatorname* { m a x } \left\{ n \mid \mathbb { E } _ { S \sim { \mathscr { D } } ^ { n } } [ \operatorname { E r r o r } _ { S } ( { \mathscr { T } } ( S ) ) ] \leq \epsilon \right\}
+$$
+
+where Error $s ( M )$ is the mean error of model $M$ on train samples $S$ .
+
+Our main hypothesis can be informally stated as follows:
+
+Hypothesis 1 (Generalized Double Descent hypothesis, informal) For any natural data distribution $\mathcal { D }$ , neural-network-based training procedure $\tau$ , and small $\epsilon > 0$ , if we consider the task of predicting labels based on n samples from $\mathcal { D }$ then:
+
+Under-paremeterized regime. If $\cdot _ { \mathrm { E M C } _ { { \mathscr D } , \epsilon } } ( \mathcal T )$ is sufficiently smaller than $n _ { \ast }$ , any perturbation of $\tau$ that increases its effective complexity will decrease the test error.
+
+Over-parameterized regime. If $\mathrm { E M C } _ { { \cal D } , \epsilon } ( T )$ is sufficiently larger than $n$ , any perturbation of $\tau$ that increases its effective complexity will decrease the test error.
+
+Critically parameterized regime. I $f \mathrm { E M C } _ { \mathcal { D } , \epsilon } ( \mathcal { T } ) \approx n$ , then a perturbation of $\tau$ that increases its effective complexity might decrease or increase the test error.
+
+Hypothesis 1 is informal in several ways. We do not have a principled way to choose the parameter $\epsilon$ (and currently heuristically use $\epsilon = 0 . 1$ ). We also are yet to have a formal specification for “sufficiently smaller” and “sufficiently larger”. Our experiments suggest that there is a critical interval around the interpolation threshold when $\mathrm { E M C } _ { \mathcal { D } , \epsilon } ( \mathcal { T } ) = n$ : below and above this interval increasing complexity helps performance, while within this interval it may hurt performance. The width of the critical interval depends on both the distribution and the training procedure in ways we do not yet completely understand.
+
+We believe Hypothesis 1 sheds light on the interaction between optimization algorithms, model size, and test performance and helps reconcile some of the competing intuitions about them. The main result of this paper is an experimental validation of Hypothesis 1 under a variety of settings, where we considered several natural choices of datasets, architectures, and optimization algorithms, and we changed the “interpolation threshold” by varying the number of model parameters, the length of training, the amount of label noise in the distribution, and the number of train samples.
+
+Model-wise Double Descent. In Section 5, we study the test error of models of increasing size, for a fixed large number of optimization steps. We show that “model-wise double-descent” occurs for various modern datasets (CIFAR-10, CIFAR-100, IWSLT‘14 de-en, with varying amounts of label noise), model architectures (CNNs, ResNets, Transformers), optimizers (SGD, Adam), number of train samples, and training procedures (data-augmentation, and regularization). Moreover, the peak in test error systematically occurs at the interpolation threshold. In particular, we demonstrate realistic settings in which bigger models are worse.
+
+Epoch-wise Double Descent. In Section 6, we study the test error of a fixed, large architecture over the course of training. We demonstrate, in similar settings as above, a corresponding peak in test performance when models are trained just long enough to reach $\approx 0$ train error. The test error of a large model first decreases (at the beginning of training), then increases (around the critical regime), then decreases once more (at the end of training)—that is, training longer can correct overfitting.
+
+Sample-wise Non-monotonicity. In Section 7, we study the test error of a fixed model and training procedure, for varying number of train samples. Consistent with our generalized double-descent hypothesis, we observe distinct test behavior in the “critical regime”, when the number of samples is near the maximum that the model can fit. This often manifests as a long plateau region, in which taking significantly more data might not help when training to completion (as is the case for CNNs on CIFAR-10). Moreover, we show settings (Transformers on IWSLT‘14 en-de), where this manifests as a peak—and for a fixed architecture and training procedure, more data actually hurts.
+
+Remarks on Label Noise. We observe all forms of double descent most strongly in settings with label noise in the train set (as is often the case when collecting train data in the real-world). However, we also show several realistic settings with a test-error peak even without label noise: ResNets (Figure 4a) and CNNs (Figure 20) on CIFAR-100; Transformers on IWSLT‘14 (Figure 8). Moreover, all our experiments demonstrate distinctly different test behavior in the critical regime— often manifesting as a “plateau” in the test error in the noiseless case which develops into a peak with added label noise. See Section 8 for further discussion.
+
+# 3 RELATED WORK
+
+Model-wise double descent was first proposed as a general phenomenon by Belkin et al. (2018). Similar behavior had been observed in Opper (1995; 2001), Advani & Saxe (2017), Spigler et al. (2018), and Geiger et al. (2019b). Subsequently, there has been a large body of work studying the double descent phenomenon. A growing list of papers that theoretically analyze it in the tractable setting of linear least squares regression includes Belkin et al. (2019); Hastie et al. (2019); Bartlett et al. (2019); Muthukumar et al. (2019); Bibas et al. (2019); Mitra (2019); Mei & Montanari (2019). Moreover, Geiger et al. (2019a) provide preliminary results for model-wise double descent in convolutional networks trained on CIFAR-10. Our work differs from the above papers in two crucial aspects: First, we extend the idea of double-descent beyond the number of parameters to incorporate the training procedure under a unified notion of “Effective Model Complexity”, leading to novel insights like epoch-wise double descent and sample non-monotonicity. The notion that increasing train time corresponds to increasing complexity was also presented in Nakkiran et al. (2019). Second, we provide an extensive and rigorous demonstration of double-descent in modern deep learning, spanning a variety of architectures, datasets, and optimization procedures. An extended discussion of the related work is provided in Appendix C.
+
+# 4 EXPERIMENTAL SETUP
+
+We briefly describe the experimental setup here; full details are in Appendix B 1. We consider three families of architectures: ResNets, standard CNNs, and Transformers. ResNets: We parameterize a family of ResNet18s (He et al. (2016)) by scaling the width (number of filters) of convolutional layers. Specifically, we use layer widths $[ k , 2 k , \bar { 4 } k , 8 k ]$ for varying $k$ . The standard ResNet18 corresponds to $k = 6 4$ . Standard CNNs: We consider a simple family of 5-layer CNNs, with 4 convolutional layers of widths $[ k , 2 k , 4 k , 8 k ]$ for varying $k$ , and a fully-connected layer. For context, the CNN with width $k = 6 4$ , can reach over $9 0 \%$ test accuracy on CIFAR-10 with dataaugmentation. Transformers: We consider the 6 layer encoder-decoder from Vaswani et al. (2017), as implemented by Ott et al. (2019). We scale the size of the network by modifying the embedding dimension $d _ { \mathrm { m o d e l } }$ , and setting the width of the fully-connected layers proportionally $( d _ { \mathrm { f f } } = 4 \cdot d _ { \mathrm { m o d e l } } )$ .
+
+For ResNets and CNNs, we train with cross-entropy loss, and the following optimizers: (1) Adam with learning-rate 0.0001 for 4K epochs; (2) SGD with learning rate $\propto \frac { 1 } { \sqrt { T } }$ for 500K gradient steps. We train Transformers for 80K gradient steps, with $10 \%$ label smoothing and no drop-out.
+
+Label Noise. In our experiments, label noise of probability $p$ refers to training on a samples which have the correct label with probability $( 1 - p )$ , and a uniformly random incorrect label otherwise (label noise is sampled only once and not per epoch). Figure 1 plots test error on the noisy distribution, while the remaining figures plot test error with respect to the clean distribution (the two curves are just linear rescaling of one another).
+
+# 5 MODEL-WISE DOUBLE DESCENT
+
+![](images/faae61f59becd773c511ccf37b8969226757057fa9adbb5ab757470a3e69071b.jpg)  
+(a) CIFAR-100. There is a peak in test error even with no label noise.   
+Figure 4: Model-wise double descent for ResNet18s. Trained on CIFAR-100 and CIFAR-10, with varying label noise. Optimized using Adam with LR 0.0001 for 4K epochs, and data-augmentation.
+
+![](images/e3fd45bf969858879ad23096c5a3e4c6e094f04bd2b0a277a1d81691dbc44055.jpg)  
+(b) CIFAR-10. There is a “plateau” in test error around the interpolation point with no label noise, which develops into a peak for added label noise.
+
+In this section, we study the test error of models of increasing size, when training to completion (for a fixed large number of optimization steps). We demonstrate model-wise double descent across different architectures, datasets, optimizers, and training procedures. The critical region exhibits distinctly different test behavior around the interpolation point and there is often a peak in test error that becomes more prominent in settings with label noise.
+
+For the experiments in this section (Figures 4, 5, 6, 7, 8), notice that all modifications which increase the interpolation threshold (such as adding label noise, using data augmentation, and increasing the number of train samples) also correspondingly shift the peak in test error towards larger models. Additional plots showing the early-stopping behavior of these models, and additional experiments showing double descent in settings with no label noise (e.g. Figure 19) are in Appendix E.2. We also observed model-wise double descent for adversarial training, with a prominent robust test error peak even in settings without label noise. See Figure 26 in Appendix E.2.
+
+Discussion. Fully understanding the mechanisms behind model-wise double descent in deep neural networks remains an important open question. However, an analog of model-wise double descent occurs even for linear models. A recent stream of theoretical works analyzes this setting (Bartlett et al. (2019); Muthukumar et al. (2019); Belkin et al. (2019); Mei & Montanari (2019); Hastie et al. (2019)). We believe similar mechanisms may be at work in deep neural networks.
+
+Informally, our intuition is that for model-sizes at the interpolation threshold, there is effectively only one model that fits the train data and this interpolating model is very sensitive to noise in the train set and/or model mis-specification. That is, since the model is just barely able to fit the train data, forcing it to fit even slightly-noisy or mis-specified labels will destroy its global structure, and result in high test error. (See Figure 28 in the Appendix for an experiment demonstrating this noise sensitivity, by showing that ensembling helps significantly in the critically-parameterized regime). However for over-parameterized models, there are many interpolating models that fit the train set, and SGD is able to find one that “memorizes” (or “absorbs”) the noise while still performing well on the distribution.
+
+![](images/44d6b8438c0d02d0c76c80ad346b4c82268cb44163651e6cd9d1516b78b9044e.jpg)  
+Figure 5: Effect of Data Augmentation. 5-layer CNNs on CIFAR10, with and without dataaugmentation. Data-augmentation shifts the interpolation threshold to the right, shifting the test error peak accordingly. Optimized using SGD for 500K steps. See Figure 27 for larger models.
+
+![](images/8100cdf1068362adc8d85ddd7ddddf0ee7d65cdfb04eb08ce1bab31e8561ac9f.jpg)
+
+![](images/f4e2caa4b4e7287a955aced3cc3d523468cc0ef98464146881383b6d073e6465.jpg)  
+Figure 6: SGD vs. Adam. 5-Layer CNNs on CIFAR-10 with no label noise, and no data augmentation. Optimized using SGD for 500K gradient steps, and Adam for 4K epochs.
+
+![](images/c8160258a06627d94e03682b0cb3a5ea98fb3a6cc2efc061ae766953b89696b3.jpg)  
+Figure 7: Noiseless settings. 5-layer CNNs on CIFAR-100 with no label noise; note the peak in test error. Trained with SGD and no data augmentation. See Figure 20 for the early-stopping behavior of these models.
+
+The above intuition is theoretically justified for linear models. In general, this situation manifests even without label noise for linear models (Mei & Montanari (2019)), and occurs whenever there is model mis-specification between the structure of the true distribution and the model family. We believe this intuition extends to deep learning as well, and it is consistent with our experiments.
+
+![](images/2b473a4c748ee138162c045888f88cd9f7560771b9e3d4fa5dd16e01c2027a36.jpg)  
+Figure 8: Transformers on language translation tasks: Multi-head-attention encoderdecoder Transformer model trained for $8 0 \mathrm { k }$ gradient steps with labeled smoothed cross-entropy loss on IWSLT‘14 Germanto-English (160K sentences) and WMT‘14 English-to-French (subsampled to 200K sentences) dataset. Test loss is measured as pertoken perplexity.
+
+# 6 EPOCH-WISE DOUBLE DESCENT
+
+In this section, we demonstrate a novel form of double-descent with respect to training epochs, which is consistent with our unified view of effective model complexity (EMC) and the generalized double descent hypothesis. Increasing the train time increases the EMC—and thus a sufficiently large model transitions from under- to over-parameterized over the course of training.
+
+![](images/bdca8d3385fd5d02c8443adb0acbb61793b4152837145966b74e283d6ca4c7db.jpg)  
+Figure 9: Left: Training dynamics for models in three regimes. Models are ResNet18s on CIFAR10 with $20 \%$ label noise, trained using Adam with learning rate 0.0001, and data augmentation. Right: Test error over (Model size $\times$ Epochs). Three slices of this plot are shown on the left.
+
+As illustrated in Figure 9, sufficiently large models can undergo a “double descent” behavior where test error first decreases then increases near the interpolation threshold, and then decreases again. In contrast, for “medium sized” models, for which training to completion will only barely reach $\approx 0$ error, the test error as a function of training time will follow a classical U-like curve where it is better to stop early. Models that are too small to reach the approximation threshold will remain in the “under parameterized” regime where increasing train time monotonically decreases test error. Our experiments (Figure 10) show that many settings of dataset and architecture exhibit epoch-wise double descent, in the presence of label noise. Further, this phenomenon is robust across optimizer variations and learning rate schedules (see additional experiments in Appendix E.1). As in modelwise double descent, the test error peak is accentuated with label noise.
+
+Conventional wisdom suggests that training is split into two phases: (1) In the first phase, the network learns a function with a small generalization gap (2) In the second phase, the network starts to over-fit the data leading to an increase in test error. Our experiments suggest that this is not the complete picture—in some regimes, the test error decreases again and may achieve a lower value at the end of training as compared to the first minimum (see Fig 10 for $10 \%$ label noise).
+
+![](images/82b708c209b3222a2c568a1bae6bfb22a279f3b426ac29068d13db60405918ac.jpg)  
+Figure 10: Epoch-wise double descent for ResNet18 and CNN (width $\scriptstyle 1 = 1 2 8$ ). ResNets trained using Adam with learning rate 0.0001, and CNNs trained with SGD with inverse-squareroot learning rate.
+
+# 7 SAMPLE-WISE NON-MONOTONICITY
+
+In this section, we investigate the effect of varying the number of train samples, for a fixed model and training procedure. Previously, in model-wise and epoch-wise double descent, we explored behavior in the critical regime, where $\mathrm { E M C } _ { \mathcal { D } , \epsilon } ( \mathcal { T } ) \approx n$ , by varying the EMC. Here, we explore the critical regime by varying the number of train samples $n$ . By increasing $n$ , the same training procedure $\tau$ can switch from being effectively over-parameterized to effectively under-parameterized.
+
+We show that increasing the number of samples has two different effects on the test error vs. model complexity graph. On the one hand, (as expected) increasing the number of samples shrinks the area under the curve. On the other hand, increasing the number of samples also has the effect of “shifting the curve to the right” and increasing the model complexity at which test error peaks.
+
+![](images/69cf7d93b6796ff455f7a65cbe3879b86a15c2ae223d5fc03fc1b54ea4f75d5d.jpg)
+
+![](images/0c5bdb0c4ceaff9263d9a08a26498be4a038c2547b0dcb1c349a3eef853ce750.jpg)
+
+(a) Model-wise double descent for 5-layer CNNs on CIFAR-10, for varying dataset sizes. Top: There is a range of model sizes (shaded green) where training on $2 \times$ more samples does not improve test error. Bottom: There is a range of model sizes (shaded red) where training on $4 \times$ more samples does not improve test error.
+
+(b) Sample-wise non-monotonicity. Test loss (per-word perplexity) as a function of number of train samples, for two transformer models trained to completion on IWSLT’14. For both model sizes, there is a regime where more samples hurt performance. Compare to Figure 3, of model-wise double-descent in the identical setting.
+
+Figure 11: Sample-wise non-monotonicity.
+
+These twin effects are shown in Figure 11a. Note that there is a range of model sizes where the effects “cancel out”—and having $4 \times$ more train samples does not help test performance when training to completion. Outside the critically-parameterized regime, for sufficiently under- or overparameterized models, having more samples helps. This phenomenon is corroborated in Figure 12, which shows test error as a function of both model and sample size, in the same setting as Figure 11a.
+
+![](images/67eb2031049b3e7bf4fd7bf3717f93c4f08018a552ffa050f6ba459a5d149a71.jpg)  
+Figure 12: Left: Test Error as a function of model size and number of train samples, for 5-layer CNNs on CIFAR- $10 + 2 0 \%$ noise. Note the ridge of high test error again lies along the interpolation threshold. Right: Three slices of the left plot, showing the effect of more data for models of different sizes. Note that, when training to completion, more data helps for small and large models, but does not help for near-critically-parameterized models (green).
+
+In some settings, these two effects combine to yield a regime of model sizes where more data actually hurts test performance as in Figure 3 (see also Figure 11b). Note that this phenomenon is not unique to DNNs: more data can hurt even for linear models (see Appendix D).
+
+# 8 CONCLUSION AND DISCUSSION
+
+We introduce a generalized double descent hypothesis: models and training procedures exhibit atypical behavior when their Effective Model Complexity is comparable to the number of train samples. We provide extensive evidence for our hypothesis in modern deep learning settings, and show that it is robust to choices of dataset, architecture, and training procedures. In particular, we demonstrate “model-wise double descent” for modern deep networks and characterize the regime where bigger models can perform worse. We also demonstrate “epoch-wise double descent,” which, to the best of our knowledge, has not been previously proposed. Finally, we show that the double descent phenomenon can lead to a regime where training on more data leads to worse test performance. Preliminary results suggest that double descent also holds as we vary the amount of regularization for a fixed model (see Figure 22).
+
+We also believe our characterization of the critical regime provides a useful way of thinking for practitioners—if a model and training procedure are just barely able to fit the train set, then small changes to the model or training procedure may yield unexpected behavior (e.g. making the model slightly larger or smaller, changing regularization, etc. may hurt test performance).
+
+Early stopping. We note that many of the phenomena that we highlight often do not occur with optimal early-stopping. However, this is consistent with our generalized double descent hypothesis: if early stopping prevents models from reaching 0 train error then we would not expect to see doubledescent, since the EMC does not reach the number of train samples. Further, we show at least one setting where model-wise double descent can still occur even with optimal early stopping (ResNets on CIFAR-100 with no label noise, see Figure 19). We have not observed settings where more data hurts when optimal early-stopping is used. However, we are not aware of reasons which preclude this from occurring. We leave fully understanding the optimal early stopping behavior of double descent as an important open question for future work.
+
+Label Noise. In our experiments, we observe double descent most strongly in settings with label noise. However, we believe this effect is not fundamentally about label noise, but rather about model mis-specification. For example, consider a setting where the label noise is not truly random, but rather pseudorandom (with respect to the family of classifiers being trained). In this setting, the performance of the Bayes optimal classifier would not change (since the pseudorandom noise is deterministic, and invertible), but we would observe an identical double descent as with truly random label noise. Thus, we view adding label noise as merely a proxy for making distributions “harder”— i.e. increasing the amount of model mis-specification.
+
+Other Notions of Model Complexity. Our notion of Effective Model Complexity is related to classical complexity notions such as Rademacher complexity, but differs in several crucial ways: (1) EMC depends on the true labels of the data distribution, and (2) EMC depends on the training procedure, not just the model architecture.
+
+Other notions of model complexity which do not incorporate features (1) and (2) would not suffice to characterize the location of the double-descent peak. Rademacher complexity, for example, is determined by the ability of a model architecture to fit a randomly-labeled train set. But Rademacher complexity and VC dimension are both insufficient to determine the model-wise double descent peak location, since they do not depend on the distribution of labels— and our experiments show that adding label noise shifts the location of the peak.
+
+Moreover, both Rademacher complexity and VC dimension depend only on the model family and data distribution, and not on the training procedure used to find models. Thus, they are not capable of capturing train-time double-descent effects, such as “epoch-wise” double descent, and the effect of data-augmentation on the peak location.
+
+# ACKNOWLEDGMENTS
+
+We thank Mikhail Belkin for extremely useful discussions in the early stages of this work. We thank Christopher Olah for suggesting the Model Size $\times$ Epoch visualization, which led to the investigation of epoch-wise double descent, as well as for useful discussion and feedback. We also thank Alec Radford, Jacob Steinhardt, and Vaishaal Shankar for helpful discussion and suggestions. P.N. thanks OpenAI, the Simons Institute, and the Harvard Theory Group for a research environment that enabled this kind of work.
+
+We thank Dimitris Kalimeris, Benjamin L. Edelman, and Sharon Qian, and Aditya Ramesh for comments on an early draft of this work.
+
+This work supported in part by NSF grant CAREER CCF 1452961, BSF grant 2014389, NSF USICCS proposal 1540428, a Google Research award, a Facebook research award, a Simons Investigator Award, a Simons Investigator Fellowship, and NSF Awards CCF 1715187, CCF 1565264, CCF 1301976, IIS 1409097, and CNS 1618026. Y.B. would like to thank the MIT-IBM Watson AI Lab for contributing computational resources for experiments.
+
+# REFERENCES
+
+Madhu S Advani and Andrew M Saxe. High-dimensional dynamics of generalization error in neural networks. arXiv preprint arXiv:1710.03667, 2017.
+
+Peter L Bartlett, Philip M Long, Gabor Lugosi, and Alexander Tsigler. Benign overfitting in linear ´ regression. arXiv preprint arXiv:1906.11300, 2019.
+
+Mikhail Belkin, Daniel Hsu, Siyuan Ma, and Soumik Mandal. Reconciling modern machine learning and the bias-variance trade-off. arXiv preprint arXiv:1812.11118, 2018.
+
+Mikhail Belkin, Daniel Hsu, and Ji Xu. Two models of double descent for weak features. arXiv preprint arXiv:1903.07571, 2019.
+
+Koby Bibas, Yaniv Fogel, and Meir Feder. A new look at an old problem: A universal learning approach to linear regression. arXiv preprint arXiv:1905.04708, 2019.
+
+Mauro Cettolo, Christian Girardi, and Marcello Federico. Wit3: Web inventory of transcribed and translated talks. In Proceedings of the $l 6 ^ { t h }$ Conference of the European Association for Machine Translation (EAMT), pp. 261–268, Trento, Italy, May 2012.
+
+Robert PW Duin. Small sample size generalization. In Proceedings of the Scandinavian Conference on Image Analysis, volume 2, pp. 957–964. PROCEEDINGS PUBLISHED BY VARIOUS PUBLISHERS, 1995.
+
+Robert PW Duin. Classifiers in almost empty spaces. In Proceedings 15th International Conference on Pattern Recognition. ICPR-2000, volume 2, pp. 1–7. IEEE, 2000.
+
+Mario Geiger, Arthur Jacot, Stefano Spigler, Franck Gabriel, Levent Sagun, Stephane d’Ascoli, ´ Giulio Biroli, Clement Hongler, and Matthieu Wyart. Scaling description of generalization with ´ number of parameters in deep learning. arXiv preprint arXiv:1901.01608, 2019a.
+
+Mario Geiger, Stefano Spigler, Stephane d’Ascoli, Levent Sagun, Marco Baity-Jesi, Giulio Biroli, ´ and Matthieu Wyart. Jamming transition as a paradigm to understand the loss landscape of deep neural networks. Physical Review E, 100(1):012115, 2019b.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Trevor Hastie, Robert Tibshirani, Jerome Friedman, and James Franklin. The elements of statistical learning: data mining, inference and prediction. The Mathematical Intelligencer, 27(2):83–85, 2005.
+
+Trevor Hastie, Andrea Montanari, Saharon Rosset, and Ryan J Tibshirani. Surprises in highdimensional ridgeless least squares interpolation. arXiv preprint arXiv:1903.08560, 2019.
+
+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.
+
+Yanping Huang, Yonglong Cheng, Dehao Chen, HyoukJoong Lee, Jiquan Ngiam, Quoc V. Le, and Zhifeng Chen. Gpipe: Efficient training of giant neural networks using pipeline parallelism. CoRR, abs/1811.06965, 2018. URL http://arxiv.org/abs/1811.06965.
+
+Alex Krizhevsky. Learning multiple layers of features from tiny images. Technical report, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012.
+
+Marco Loog and Robert PW Duin. The dipping phenomenon. In Joint IAPR International Workshops on Statistical Techniques in Pattern Recognition (SPR) and Structural and Syntactic Pattern Recognition (SSPR), pp. 310–317. Springer, 2012.
+
+Aleksander Madry, Aleksandar Makelov, Ludwig Schmidt, Dimitris Tsipras, and Adrian Vladu. Towards deep learning models resistant to adversarial attacks. arXiv preprint arXiv:1706.06083, 2017.
+
+Song Mei and Andrea Montanari. The generalization error of random features regression: Precise asymptotics and double descent curve. arXiv preprint arXiv:1908.05355, 2019.
+
+Partha P. Mitra. Understanding overfitting peaks in generalization error: Analytical risk curves for l2 and l1 penalized interpolation. ArXiv, abs/1906.03667, 2019.
+
+Vidya Muthukumar, Kailas Vodrahalli, and Anant Sahai. Harmless interpolation of noisy data in regression. arXiv preprint arXiv:1903.09139, 2019.
+
+Preetum Nakkiran, Gal Kaplun, Dimitris Kalimeris, Tristan Yang, Benjamin L Edelman, Fred Zhang, and Boaz Barak. Sgd on neural networks learns functions of increasing complexity. arXiv preprint arXiv:1905.11604, 2019.
+
+Brady Neal, Sarthak Mittal, Aristide Baratin, Vinayak Tantia, Matthew Scicluna, Simon LacosteJulien, and Ioannis Mitliagkas. A modern take on the bias-variance tradeoff in neural networks. arXiv preprint arXiv:1810.08591, 2018.
+
+Manfred Opper. Statistical mechanics of learning: Generalization. The Handbook of Brain Theory and Neural Networks, 922-925., 1995.
+
+Manfred Opper. Learning to generalize. Frontiers of Life, 3(part 2), pp.763-775., 2001.
+
+Myle Ott, Sergey Edunov, Alexei Baevski, Angela Fan, Sam Gross, Nathan $\mathrm { N g }$ , David Grangier, and Michael Auli. fairseq: A fast, extensible toolkit for sequence modeling. In Proceedings of NAACL-HLT 2019: Demonstrations, 2019.
+
+David Page. How to train your resnet. https://myrtle.ai/ how-to-train-your-resnet-4-architecture/, 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. In NeurIPS Autodiff Workshop, 2017.
+
+Alec Radford, Jeff Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. 2019.
+
+Ali Rahimi and Benjamin Recht. Random features for large-scale kernel machines. In Advances in neural information processing systems, pp. 1177–1184, 2008.
+
+Rico Sennrich, Barry Haddow, and Alexandra Birch. Neural machine translation of rare words with subword units. ArXiv, abs/1508.07909, 2015.
+
+Marina Skurichina and Robert PW Duin. Bagging, boosting and the random subspace method for linear classifiers. Pattern Analysis & Applications, 5(2):121–135, 2002.
+
+Stefano Spigler, Mario Geiger, Stephane d’Ascoli, Levent Sagun, Giulio Biroli, and Matthieu Wyart.´ A jamming transition from under-to over-parametrization affects loss landscape and generalization. arXiv preprint arXiv:1810.09665, 2018.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In Computer Vision and Pattern Recognition (CVPR), 2015. URL http://arxiv.org/abs/ 1409.4842.
+
+Gerard V Trunk. A problem of dimensionality: A simple example. IEEE Transactions on pattern analysis and machine intelligence, (3):306–307, 1979.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. CoRR, abs/1706.03762, 2017.
+
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. ICLR, abs/1611.03530, 2016.
+
+A SUMMARY TABLE OF EXPERIMENTAL RESULTS   
+
+<table><tr><td rowspan="2">Dataset</td><td rowspan="2">Architecture</td><td rowspan="2">Opt.</td><td rowspan="2">Aug.</td><td rowspan="2">% Noise</td><td colspan="2">Double-Descent</td><td rowspan="2">Figure(s)</td></tr><tr><td>Model</td><td>Epoch</td></tr><tr><td>CIFAR 10</td><td>CNN</td><td>SGD</td><td>√</td><td>0</td><td>X</td><td>×</td><td>5,27</td></tr><tr><td rowspan="10"></td><td></td><td></td><td>√</td><td>10</td><td>广</td><td>广</td><td>5,27,6</td></tr><tr><td></td><td></td><td>√</td><td>20</td><td></td><td></td><td>5,27</td></tr><tr><td></td><td></td><td></td><td>0</td><td>X</td><td>x√</td><td>5,25</td></tr><tr><td></td><td></td><td></td><td>10</td><td></td><td></td><td>5</td></tr><tr><td></td><td></td><td></td><td>20</td><td>√</td><td>√</td><td>5</td></tr><tr><td></td><td>SGD + w.d.</td><td>√</td><td>20</td><td>√</td><td>√</td><td>21</td></tr><tr><td>ResNet</td><td>Adam</td><td></td><td>0</td><td>√</td><td></td><td>25</td></tr><tr><td>Adam</td><td>√</td><td>0</td><td>X</td><td></td><td>X</td><td>4,10</td></tr><tr><td></td><td>√</td><td>5</td><td>√</td><td></td><td></td><td>4</td></tr><tr><td></td><td>√</td><td>10</td><td></td><td></td><td></td><td>4,10</td></tr><tr><td></td><td></td><td>√</td><td>15</td><td>√</td><td></td><td>4,2</td></tr><tr><td rowspan="2"></td><td></td><td>Various</td><td>√</td><td>20</td><td>√</td><td></td><td>4,9,10</td></tr><tr><td></td><td></td><td>√</td><td>20</td><td></td><td>√</td><td>16, 17, 18</td></tr><tr><td rowspan="2">(subsampled)</td><td>CNN</td><td>SGD SGD</td><td>√</td><td>10</td><td>√</td><td></td><td>11a</td></tr><tr><td></td><td></td><td>√</td><td>20</td><td>√</td><td></td><td>11a, 12</td></tr><tr><td>(adversarial)</td><td>ResNet</td><td>SGD</td><td></td><td>0</td><td>Robust err.</td><td></td><td>26</td></tr><tr><td rowspan="4">CIFAR 100</td><td>ResNet</td><td>Adam</td><td></td><td>0</td><td>√</td><td>X</td><td>4,19,10</td></tr><tr><td></td><td></td><td>&gt;&gt;</td><td>10</td><td>√</td><td>√</td><td>4,10</td></tr><tr><td>CNN</td><td>SGD</td><td>√</td><td>20</td><td>√</td><td>√</td><td>4,10</td></tr><tr><td></td><td></td><td></td><td>0</td><td>√</td><td>X</td><td>20</td></tr><tr><td>IWSLT &#x27;14 de-en</td><td>Transformer</td><td>Adam</td><td></td><td>0</td><td>√</td><td>X</td><td>8,24</td></tr><tr><td>(subsampled)</td><td>Transformer</td><td>Adam</td><td></td><td>0</td><td>√</td><td>X</td><td>11b,23</td></tr><tr><td>WMT&#x27;14 en-fr</td><td>Transformer</td><td>Adam</td><td></td><td>0</td><td>√</td><td>X</td><td>8,24</td></tr></table>
+
+# B APPENDIX: EXPERIMENTAL DETAILS
+
+# B.1 MODELS
+
+We use the following families of architectures. The PyTorch Paszke et al. (2017) specification of our ResNets and CNNs are available at https://gitlab.com/ harvard-machine-learning/double-descent/tree/master.
+
+ResNets. We define a family of ResNet18s of increasing size as follows. We follow the Preactivation ResNet18 architecture of He et al. (2016), using 4 ResNet blocks, each consisting of two BatchNorm-ReLU-Convolution layers. The layer widths for the 4 blocks are $[ k , 2 k , 4 k , 8 k ]$ for varying $k \in \mathbb N$ and the strides are [1, 2, 2, 2]. The standard ResNet18 corresponds to $k = 6 4$ convolutional channels in the first layer. The scaling of model size with $k$ is shown in Figure 13b. Our implementation is adapted from https://github.com/kuangliu/pytorch-cifar.
+
+Standard CNNs. We consider a simple family of 5-layer CNNs, with four Conv-BatchNormReLU-MaxPool layers and a fully-connected output layer. We scale the four convolutional layer widths as $[ k , 2 k , 4 k , 8 k ]$ . The MaxPool is [1, 2, 2, 8]. For all the convolution layers, the kernel size $= 3$ , stride $= 1$ and padding $^ { = 1 }$ . This architecture is based on the “backbone” architecture from Page (2018). For $k = 6 4$ , this CNN has 1558026 parameters and can reach $> 9 0 \%$ test accuracy on CIFAR-10 (Krizhevsky (2009)) with data-augmentation. The scaling of model size with $k$ is shown in Figure 13a.
+
+Transformers. We consider the encoder-decoder Transformer model from Vaswani et al. (2017) with 6 layers and 8 attention heads per layer, as implemented by fairseq Ott et al. (2019). We scale the size of the network by modifying the embedding dimension $( d _ { \mathrm { m o d e l } } )$ , and scale the width of the fully-connected layers proportionally $\begin{array} { r } { \dot { \mathcal { d } } _ { \mathrm { f f } } = 4 { d } _ { \mathrm { m o d e l } } ) } \end{array}$ . We train with $10 \%$ label smoothing and no drop-out, for 80 gradient steps.
+
+![](images/d8516fb233b07ebcdc7f08ef74910030a4bc584afa359c5fbd7737999a56c148.jpg)  
+Figure 13: Scaling of model size with our parameterization of width & embedding dimension.
+
+B.2 IMAGE CLASSIFICATION: EXPERIMENTAL SETUP
+
+We describe the details of training for CNNs and ResNets below.
+
+Loss function: Unless stated otherwise, we use the cross-entropy loss for all the experiments.
+
+Data-augmentation: In experiments where data-augmentation was used, we apply RandomCrop(32, padding ${ \cdot = } 4$ ) and RandomHorizontalFlip. In experiments with added label noise, the label for all augmentations of a given training sample are given the same label.
+
+Regularization: No explicit regularization like weight decay or dropout was applied unless explicitly stated.
+
+Initialization: We use the default initialization provided by PyTorch for all the layers.
+
+# Optimization:
+
+• Adam: Unless specified otherwise, learning rate was set at constant to 1e−4 and all other parameters were set to their default PyTorch values.   
+SGD: Unless specified otherwise, learning rate schedule inverse-square root (defined below) was used with initial learning rate $\gamma _ { 0 } = 0 . 1$ and updates every $L = 5 1 2$ gradient steps. No momentum was used.
+
+We found our results are robust to various other natural choices of optimizers and learning rate schedule. We used the above settings because (1) they optimize well, and (2) they do not require experiment-specific hyperparameter tuning, and allow us to use the same optimization across many experiments.
+
+Batch size: All experiments use a batchsize of 128.
+
+# Learning rate schedule descriptions:
+
+• Inverse-square root $( \gamma _ { 0 } , L )$ : At gradient step $t$ , the learning rate is set to $\gamma ( t ) : =$ $\frac { \gamma _ { 0 } } { \sqrt { 1 + \lfloor t / 5 1 2 \rfloor } }$ . We set learning-rate with respect to number of gradient steps, and not epochs, in order to allow comparison between experiments with varying train-set sizes. • Dynamic drop ( $\mathrm { \Delta } \cdot \mathrm { \Delta } \gamma _ { 0 }$ , drop, patience): Starts with an initial learning rate of $\gamma _ { 0 }$ and drops by a factor of ’drop’ if the training loss has remained constant or become worse for ’patience’ number of gradient steps.
+
+B.3 NEURAL MACHINE TRANSLATION: EXPERIMENTAL SETUP
+
+Here we describe the experimental setup for the neural machine translation experiments.
+
+# Training procedure.
+
+In this setting, the distribution $\mathcal { D }$ consists of triples
+
+$$
+( x , y , i ) : x \in V _ { s r c } ^ { * } , y \in V _ { t g t } ^ { * } , i \in \{ 0 , \ldots , | y | \}
+$$
+
+where $V _ { s r c }$ and $V _ { t g t }$ are the source and target vocabularies, the string $x$ is a sentence in the source language, $y$ is its translation in the target language, and $i$ is the index of the token to be predicted by the model. We assume that $i | x , y$ is distributed uniformly on $\{ 0 , \ldots , | y | \}$ .
+
+A standard probabilistic model defines an autoregressive factorization of the likelihood:
+
+$$
+p _ { M } ( y | x ) = \prod _ { i = 1 } ^ { | y | } p _ { M } ( y _ { i } | y _ { < i } , x ) .
+$$
+
+Given a set of training samples $S$ , we define
+
+$$
+\operatorname { E r r o r } _ { S } ( M ) = { \frac { 1 } { | S | } } \sum _ { ( x , y , i ) \in S } - \log p _ { M } ( y _ { i } | y _ { < i } , x ) .
+$$
+
+In practice, $S$ is not constructed from independent samples from $D$ , but rather by first sampling $( x , y )$ and then including all $( x , y , 0 ) , \dotsc , ( x , y , | y | )$ in $S$ .
+
+For training transformers, we replicate the optimization procedure specified in Vaswani et al. (2017) section 5.3, where the learning rate schedule consists of a “warmup” phase with linearly increasing learning rate followed by a phase with inverse square-root decay. We preprocess the data using byte pair encoding (BPE) as described in Sennrich et al. (2015). We use the implementation provided by fairseq (https://github.com/pytorch/fairseq).
+
+Datasets. The IWSLT ’14 German to English dataset contains TED Talks as described in Cettolo et al. (2012). The WMT ’14 English to French dataset is taken from http://www.statmt. org/wmt14/translation-task.html.
+
+# B.4 PER-SECTION EXPERIMENTAL DETAILS
+
+Here we provide full details for experiments in the body, when not otherwise provided.
+
+Introduction: Experimental Details Figure 1: All models were trained using Adam with learningrate 0.0001 for 4K epochs. Plotting means and standard deviations for 5 trials, with random network initialization.
+
+Model-wise Double Descent: Experimental Details Figure 7: Plotting means and standard deviations for 5 trials, with random network initialization.
+
+Sample-wise Nonmonotonicity: Experimental Details Figure 11a: All models are trained with SGD for 500K epochs, and data-augmentation. Bottom: Means and standard deviations from 5 trials with random initialization, and random subsampling of the train set.
+
+# C EXTENDED DISCUSSION OF RELATED WORK
+
+Belkin et al. (2018): This paper proposed, in very general terms, that the apparent contradiction between traditional notions of the bias-variance trade-off and empirically successful practices in deep learning can be reconciled under a double-descent curve—as model complexity increases, the test error follows the traditional “U-shaped curve”, but beyond the point of interpolation, the error starts to decrease. This work provides empirical evidence for the double-descent curve with fully connected networks trained on subsets of MNIST, CIFAR10, SVHN and TIMIT datasets. They use the $l _ { 2 }$ loss for their experiments. They demonstrate that neural networks are not an aberration in this regard—double-descent is a general phenomenon observed also in linear regression with random features and random forests.
+
+Theoretical works on linear least squares regression: A variety of papers have attempted to theoretically analyze this behavior in restricted settings, particularly the case of least squares regression under various assumptions on the training data, feature spaces and regularization method.
+
+1. Advani & Saxe (2017); Hastie et al. (2019) both consider the linear regression problem stated above and analyze the generalization behavior in the asymptotic limit $N , D \to \infty$ using random matrix theory. Hastie et al. (2019) highlight that when the model is misspecified, the minimum of training error can occur for over-parameterized models   
+2. Belkin et al. (2019) Linear least squares regression for two data models, where the input data is sampled from a Gaussian and a Fourier series model for functions on a circle. They provide a finite-sample analysis for these two cases   
+3. Bartlett et al. (2019) provides generalization bounds for the minimum $l _ { 2 }$ -norm interpolant for Gaussian features   
+4. Muthukumar et al. (2019) characterize the fundamental limit of of any interpolating solution in the presence of noise and provide some interesting Fourier-theoretic interpretations.   
+5. Mei & Montanari (2019): This work provides asymptotic analysis for ridge regression over random features
+
+Similar double descent behavior, in restricted settings, was investigated in Trunk (1979); Opper (1995; 2001); Skurichina & Duin (2002).
+
+Neal et al. (2018) conducts a study of bias and variance in modern neural networks, observing that both bias and variance can decrease with increasing model size, contrary to conventional wisdom.
+
+Geiger et al. (2019b) showed that deep fully connected networks trained on the MNIST dataset with hinge loss exhibit a “jamming transition” when the number of parameters exceeds a threshold that allows training to near-zero train loss. Geiger et al. (2019a) provide further experiments on CIFAR10 with a convolutional network. They also highlight interesting behavior with ensembling around the critical regime, which is consistent with our informal intuitions in Section 5 and our experiments in Figures 28, 29.
+
+Advani & Saxe (2017); Geiger et al. (2019b;a) also point out that double-descent is not observed when optimal early-stopping is used.
+
+The study of sample non-monotonicity in learning algorithms had also existed prior to double descent, including in Duin (1995; 2000); Opper (2001); Loog & Duin (2012).
+
+![](images/228a2efe993d5a5b8de88a94c4213a4344f8bf8c59e0d4b46ffa29d81cf9c5ed.jpg)  
+Figure 14: Random Fourier Features on the Fashion MNIST dataset. The setting is equivalent to two-layer neural network with $e ^ { - i x }$ activation, with randomly-initialized first layer that is fixed throughout training. The second layer is trained using gradient flow.
+
+In this section, for completeness sake, we show that both the model- and sample-wise double descent phenomena are not unique to deep neural networks—they exist even in the setting of Random Fourier Features of Rahimi & Recht (2008). This setting is equivalent to a two-layer neural network with $e ^ { - i x }$ activation. The first layer is initialized with a $\textstyle { \hat { \mathcal { N } } } ( 0 , { \frac { 1 } { d } } )$ Gaussian distribution and then fixed throughout training. The width (or embedding dimension) $\dot { d }$ of the first layer parameterizes the model size. The second layer is initialized with 0s and trained with MSE loss.
+
+Figure 14 shows the grid of Test Error as a function of both number of samples $n$ and model size $d$ . Note that in this setting $\mathrm { E M C } = d$ (the embedding dimension). As a result, as demonstrated in the figure, the peak follows the path of $n = d$ . Both model-wise and sample-wise (see figure 15) double descent phenomena are captured, by horizontally and vertically crossing the grid, respectively.
+
+![](images/d3b8ed60787a0868c3f5be52fec305d08ff718efc3f20f3f4f5d527b1d16e3f6.jpg)  
+Figure 15: Sample-wise double-descent slice for Random Fourier Features on the Fashion MNIST dataset. In this figure the embedding dimension (number of random features) is 1000.
+
+# E APPENDIX: ADDITIONAL EXPERIMENTS
+
+E.1 EPOCH-WISE DOUBLE DESCENT: ADDITIONAL RESULTS
+
+Here, we provide a rigorous evaluation of epoch-wise double descent for a variety of optimizers and learning rate schedules. We train ResNet18 on CIFAR-10 with data-augmentation and $20 \%$ label noise with three different optimizers—Adam, SGD, SGD $^ +$ Momentum (momentum set to 0.9) and three different learning rate schedules—constant, inverse-square root, dynamic drop for differnet values of initial learning rate. We observe that double-descent occurs reliably for all optimizers and learning rate schedules and the peak of the double descent curve shifts with the interpolation point.
+
+![](images/58c1328435c48b2aab09317e06f4603fa0a9e59b7a92dde853e7a8bf3b824794.jpg)  
+Figure 16: Epoch-wise double descent for ResNet18 trained with Adam and multiple learning rate schedules
+
+A practical recommendation resulting from epoch-wise double descent is that stopping the training when the test error starts to increase may not always be the best strategy. In some cases, the test error may decrease again after reaching a maximum, and the final value may be lower than the minimum earlier in training.
+
+![](images/1008ca2f366058ba1435cf28efaa611f9c9131e1be26e429651a63223e79e1f5.jpg)  
+Figure 17: Epoch-wise double descent for ResNet18 trained with SGD and multiple learning rate schedules
+
+![](images/488e30e35257cba7429094f8ccf62b9894c5a64f45fd96a4c9ac9360e41020b6.jpg)  
+Figure 18: Epoch-wise double descent for ResNet18 trained with $\mathrm { S G D + I }$ Momentum and multiple learning rate schedules
+
+E.2 MODEL-WISE DOUBLE DESCENT: ADDITIONAL RESULTS
+
+# E.2.1 CLEAN SETTINGS WITH MODEL-WISE DOUBLE DESCENT
+
+CIFAR100, ResNet18
+
+![](images/5210617de1e3afc414e784be266f4144de44d71b2df97b8df3a125339670d3a0.jpg)  
+Figure 19: Top: Train and test performance as a function of both model size and train epochs. Bottom: Test error dynamics of the same model (ResNet18, on CIFAR-100 with no label noise, data-augmentation and Adam optimizer trained for $4 \mathrm { k }$ epochs with learning rate 0.0001). Note that even with optimal early stopping this setting exhibits double descent.
+
+![](images/fb960e5034da77700c7a7fd448a34568a0bb5b897f622766da0a04bb8ae57ec4.jpg)  
+Figure 20: Top: Train and test performance as a function of both model size and train epochs. Bottom: Test error dynamics of the same models. 5-Layer CNNs, CIFAR-100 with no label noise, no data-augmentation Trained with SGD for 1e6 steps. Same experiment as Figure 7.
+
+![](images/81c77025d124fca35d30178bb0aa53f7ec90c4883061d61bfdb0b4ef4870d8cc.jpg)  
+Figure 21: Left: Test error dynamics with weight decay of 5e-4 (bottom left) and without weight decay (top left). Right: Test and train error and test loss for models with varying amounts of weight decay. All models are 5-Layer CNNs on CIFAR-10 with $10 \%$ label noise, trained with data-augmentation and SGD for 500K steps.
+
+Here, we now study the effect of varying the level of regularization on test error. We train CIFAR10 with data-augmentation and $20 \%$ label noise on ResNet18 for weight decay co-efficients $\lambda$ ranging from 0 to 0.1. We train the networks using $\mathrm { S G D + }$ inverse-square root learning rate. Figure below shows a picture qualitatively very similar to that observed for model-wise double descent wherein ”model complexity” is now controlled by the regularization parameter. This confirms our generalized double descent hypothesis along yet another axis of Effective Model Complexity.
+
+![](images/2d026f82df05ae4f47eb2f36c18491bb8ff9cd5ddf873d309f4c7bc3b3b3c258.jpg)  
+Figure 22: Generalized double descent for weight decay. We found that using the same initial learning rate for all weight decay values led to training instabilities. This resulted in some noise in the Test Error (Weight Decay $\times$ Epochs) plot shown above.
+
+Language models
+
+![](images/ceaf06ca3257454a126e72ecfe328fbca78241c7e0b1b27a9af01838536e68eb.jpg)  
+Figure 23: Model-wise test error dynamics for a subsampled IWSLT‘14 dataset. Left: 4k samples, Right: 18k samples. Note that with optimal early-stopping, more samples is always better.
+
+![](images/548a288bc91ae0609a7c35054d158b13e6149f1b900a2a3870f131fa4fc14015.jpg)  
+Figure 24: Model-wise test error dynamics for a IWSLT‘14 de-en and subsampled WMT‘14 en-fr datasets. Left: IWSLT‘14, Right: subsampled (200k samples) WMT‘14. Note that with optimal early-stopping, the test error is much lower for this task.
+
+CIFAR10, $10 \%$ noise, SGD
+
+![](images/329ab7efcf3819680ed22e9d04f97aecbd6fd2941d5217d8d45d006ce1c162c0.jpg)  
+Figure 25: Top: Train and test performance as a function of both model size and train epochs. Bottom: Test error dynamics of the same model (CNN, on CIFAR-10 with $10 \%$ label noise, dataaugmentation and SGD optimizer with learning rate $\propto 1 / \sqrt { T } )$ ).
+
+# E.2.4 TRAINING PROCEDURE
+
+![](images/cce2a82acf0147228634fdd0581f2e67796b76009678007530194689d914a4f5.jpg)  
+Figure 26: Model-wise double descent for adversarial training ResNet18s on CIFAR-10 (subsampled to $2 5 \mathrm { k }$ train samples) with no label noise. We train for L2 robustness of radius $\epsilon = 0 . 5$ and $\epsilon = 1 . 0$ , using 10-step PGD (Goodfellow et al. (2014); Madry et al. (2017)). Trained using SGD (batch size 128) with learning rate 0.1 for 400 epochs, then 0.01 for 400 epochs.
+
+![](images/3f166e910507b6f677862e70ccd9d2fcc5d745118d0ea7693bdfe992dda82c23.jpg)  
+Figure 27
+
+![](images/92155799e3b955426cfd287a4260029a284a4655cd2cd750acbb4e3c8ec8bdcc.jpg)  
+Figure 28: Effect of Ensembling (ResNets, $15 \%$ label noise). Test error of an ensemble of 5 models, compared to the base models. The ensembled classifier is determined by plurality vote over the 5 base models. Note that emsembling helps most around the critical regime. All models are ResNet18s trained on CIFAR-10 with $15 \%$ label noise, using Adam for 4K epochs (same setting as Figure 1). Test error is measured against the original (not noisy) test set, and each model in the ensemble is trained using a train set with independently-sampled $15 \%$ label noise.
+
+![](images/b3feb5b8e7fb91ef88b906092c18d0ee5c04fae19b187b34bbe97bc9c5642f30.jpg)  
+Figure 29: Effect of Ensembling (CNNs, no label noise). Test error of an ensemble of 5 models, compared to the base models. All models are 5-layer CNNs trained on CIFAR-10 with no label noise, using SGD and no data augmentation. (same setting as Figure 7).

parse/train/B1n8LexRZ/B1n8LexRZ.md

@@ -0,0 +1,438 @@
+# GENERALIZING HAMILTONIAN MONTE CARLO WITH NEURAL NETWORKS
+
+Daniel Levy1∗, Matthew D. Hoffman2, Jascha Sohl-Dickstein3 1Stanford University, 2Google AI Perception , 3Google Brain danilevy@cs.stanford.edu, {mhoffman,jaschasd}@google.com
+
+# ABSTRACT
+
+We present a general-purpose method to train Markov chain Monte Carlo kernels, parameterized by deep neural networks, that converge and mix quickly to their target distribution. Our method generalizes Hamiltonian Monte Carlo and is trained to maximize expected squared jumped distance, a proxy for mixing speed. We demonstrate large empirical gains on a collection of simple but challenging distributions, for instance achieving a $1 0 6 \times$ improvement in effective sample size in one case, and mixing when standard HMC makes no measurable progress in a second. Finally, we show quantitative and qualitative gains on a real-world task: latent-variable generative modeling. We release an open source TensorFlow implementation of the algorithm.
+
+# 1 INTRODUCTION
+
+High-dimensional distributions that are only analytically tractable up to a normalizing constant are ubiquitous in many fields. For instance, they arise in protein folding (Schutte et al., 1999), physics ¨ simulations (Olsson, 1995), and machine learning (Andrieu et al., 2003). Sampling from such distributions is a critical task for learning and inference (MacKay, 2003), however it is an extremely hard problem in general.
+
+Markov Chain Monte Carlo (MCMC) methods promise a solution to this problem. They operate by generating a sequence of correlated samples that converge in distribution to the target. This convergence is most often guaranteed through detailed balance, a sufficient condition for the chain to have the target equilibrium distribution. In practice, for any proposal distribution, one can ensure detailed balance through a Metropolis-Hastings (Hastings, 1970) accept/reject step.
+
+Despite theoretical guarantees of eventual convergence, in practice convergence and mixing speed depend strongly on choosing a proposal that works well for the task at hand. What’s more, it is often more art than science to know when an MCMC chain has converged (“burned-in”), and when the chain has produced a new uncorrelated sample (“mixed”). Additionally, the reliance on detailed balance, which assigns equal probability to the forward and reverse transitions, often encourages random-walk behavior and thus slows exploration of the space (Ichiki & Ohzeki, 2013).
+
+For densities over continuous spaces, Hamiltonian Monte Carlo (HMC; Duane et al., 1987; Neal, 2011) introduces independent, auxiliary momentum variables, and computes a new state by integrating Hamiltonian dynamics. This method can traverse long distances in state space with a single Metropolis-Hastings test. This is the state-of-the-art method for sampling in many domains. However, HMC can perform poorly in a number of settings. While HMC mixes quickly spatially, it struggles at mixing across energy levels due to its volume-preserving dynamics. HMC also does not work well with multi-modal distributions, as the probability of sampling a large enough momentum to traverse a very low-density region is negligibly small. Furthermore, HMC struggles with ill-conditioned energy landscapes (Girolami & Calderhead, 2011) and deals poorly with rapidly changing gradients (Sohl-Dickstein et al., 2014).
+
+Recently, probabilistic models parameterized by deep neural networks have achieved great success at approximately sampling from highly complex, multi-modal empirical distributions (Kingma &
+
+Welling, 2013; Rezende et al., 2014; Goodfellow et al., 2014; Bengio et al., 2014; Sohl-Dickstein et al., 2015). Building on these successes, we present a method that, given an analytically described distribution, automatically returns an exact sampler with good convergence and mixing properties, from a class of highly expressive parametric models. The proposed family of samplers is a generalization of HMC; it transforms the HMC trajectory using parametric functions (deep networks in our experiments), while retaining theoretical guarantees with a tractable Metropolis-Hastings accept/reject step. The sampler is trained to minimize a variation on expected squared jumped distance (similar in spirit to Pasarica & Gelman (2010)). Our parameterization reduces easily to standard HMC. It is further capable of emulating several common extensions of HMC such as withintrajectory tempering (Neal, 1996) and diagonal mass matrices (Bennett, 1975).
+
+We evaluate our method on distributions where HMC usually struggles, as well as on a the real-world task of training latent-variable generative models.
+
+Our contributions are as follows:
+
+• We introduce a generic training procedure which takes as input a distribution defined by an energy function, and returns a fast-mixing MCMC kernel.   
+• We show significant empirical gains on various distributions where HMC performs poorly.   
+• We finally evaluate our method on the real-world task of training and sampling from a latent variable generative model, where we show improvement in the model’s log-likelihood, and greater complexity in the distribution of posterior samples.
+
+# 2 RELATED WORK
+
+Adaptively modifying proposal distributions to improve convergence and mixing has been explored in the past (Andrieu & Thoms, 2008). In the case of HMC, prior work has reduced the need to choose step size (Neal, 2011) or number of leapfrog steps (Hoffman & Gelman, 2014) by adaptively tuning those parameters. Salimans et al. (2015) proposed an alternate scheme based on variational inference. We adopt the much simpler approach of Pasarica & Gelman (2010), who show that choosing the hyperparameters of a proposal distribution to maximize expected squared jumped distance is both principled and effective in practice.
+
+Previous work has also explored applying models from machine learning to MCMC tasks. Kernel methods have been used both for learning a proposal distribution (Sejdinovic et al., 2014) and for approximating the gradient of the energy (Strathmann et al., 2015). In physics, Restricted and semiRestricted Boltzmann machines have been used both to build approximations of the energy function which allow more rapid sampling (Liu et al., 2017; Huang & Wang, 2017), and to motivate new hand-designed proposals (Wang, 2017).
+
+Most similar to our approach is recent work from Song et al. (2017), which uses adversarial training of a volume-preserving transformation, which is subsequently used as an MCMC proposal distribution. While promising, this technique has several limitations. It does not use gradient information, which is often crucial to maintaining high acceptance rates, especially in high dimensions. It also can only indirectly measure the quality of the generated sample using adversarial training, which is notoriously unstable, suffers from “mode collapse” (where only a portion of a target distribution is covered), and often requires objective modification to train in practice (Arjovsky et al., 2017). Finally, since the proposal transformation preserves volume, it can suffer from the same difficulties in mixing across energy levels as HMC, as we illustrate in Section 5.
+
+To compute the Metropolis-Hastings acceptance probability for a deterministic transition, the operator must be invertible and have a tractable Jacobian. Recent work (Dinh et al., 2016), introduces RNVP, an invertible transformation that operates by, at each layer, modifying only a subset of the variables by a function that depends solely on the remaining variables. This is exactly invertible with an efficiently computable Jacobian. Furthermore, by chaining enough of these layers, the model can be made arbitrarily expressive. This parameterization will directly motivate our extension of the leapfrog integrator in HMC.
+
+# 3 BACKGROUND
+
+# 3.1 MCMC METHODS AND METROPOLIS-HASTINGS
+
+Let $p$ be a target distribution, analytically known up to a constant, over a space $\mathcal { X }$ . Markov chain Monte Carlo (MCMC) methods (Neal, 1993) aim to provide samples from $p$ . To that end, MCMC methods construct a Markov Chain whose stationary distribution is the target distribution $p$ . Obtaining samples then corresponds to simulating a Markov Chain, i.e., given an initial distribution $\pi _ { 0 }$ and a transition kernel $K$ , constructing the following sequence of random variables:
+
+$$
+X _ { 0 } \sim \pi _ { 0 } , \quad X _ { t + 1 } \sim K ( \cdot | X _ { t } ) .
+$$
+
+In order for $p$ to be the stationary distribution of the chain, three conditions must be satisfied: $K$ must be irreducible and aperiodic (these are usually mild technical conditions) and $p$ has to be a fixed point of $K$ . This last condition can be expressed as: $\begin{array} { r } { p ( x ^ { \prime } ) = \int K ( x ^ { \prime } | x ) p ( x ) \mathrm { d } x } \end{array}$ . This condition is most often satisfied by satisfying the stronger detailed balance condition, which can be written as: $p ( x ^ { \prime } ) K ( x | x ^ { \prime } ) = p ( x ) \dot { K } ( x ^ { \prime } | \dot { x } )$ .
+
+Given any proposal distribution $q$ , satisfying mild conditions, we can easily construct a transition kernel that respects detailed balance using Metropolis-Hastings (Hastings, 1970) accept/reject rules. More formally, starting from $x _ { 0 } \sim \pi _ { 0 }$ , at each step $t$ , we sample $x ^ { \prime } \sim q ( \cdot | X _ { t } )$ , and with probability $\begin{array} { r } { A ( x ^ { \prime } | x _ { t } ) = \operatorname* { m i n } \left( 1 , \frac { p ( x ^ { \prime } ) q ( x _ { t } | x ^ { \prime } ) } { p ( x _ { t } ) q ( x ^ { \prime } | x _ { t } ) } \right) } \end{array}$ , accept $x ^ { \prime }$ as the next sample $x _ { t + 1 }$ in the chain. If we reject $x ^ { \prime }$ , then we retain the previous state and $x _ { t + 1 } ~ = ~ x _ { t }$ . For typical proposals this algorithm has strong asymptotic guarantees. But in practice one must often choose between very low acceptance probabilities and very cautious proposals, both of which lead to slow mixing. For continuous state spaces, Hamiltonian Monte Carlo (HMC; Neal, 2011) tackles this problem by proposing updates that move far in state space while staying roughly on iso-probability contours of $p$ .
+
+# 3.2 HAMILTONIAN MONTE CARLO
+
+Without loss of generality, we assume $p \left( x \right)$ to be defined by an energy function $U \left( x \right)$ , s.t. $p ( x ) \propto \exp ( - U ( { \bar { x } } ) )$ , and where the state $x \in \mathbb { R } ^ { n }$ . HMC extends the state space with an additional momentum vector $v \in \mathbb { R } ^ { n }$ , where $v$ is distributed independently from $x$ , as $p ( v ) \propto \exp ( - \frac { 1 } { 2 } v ^ { T } v )$ (i.e., identity-covariance Gaussian). From an augmented state $\xi \triangleq ( x , v )$ , HMC produces a proposed state $\xi ^ { \prime } = ( \dot { x } ^ { \prime } , v ^ { \prime } )$ by approximately integrating Hamiltonian dynamics jointly on $x$ and $v$ , with $U \left( x \right)$ taken to be the potential energy, and $\scriptstyle { \frac { 1 } { 2 } } v ^ { \overline { { T } } } v$ the kinetic energy. Since Hamiltonian dynamics conserve the total energy of a system, their approximate integration moves along approximate iso-probability contours of $p \bar { ( \boldsymbol { x } , \boldsymbol { v } ) } = \bar { p } ( \boldsymbol { x } ) p ( \boldsymbol { v } )$ .
+
+The dynamics are typically simulated using the leapfrog integrator (Hairer et al., 2003; Leimkuhler & Reich, 2004), which for a single time step consists of:
+
+$$
+\begin{array} { r } { v ^ { \frac { 1 } { 2 } } = v - \frac { \epsilon } { 2 } \partial _ { x } U ( x ) ; \quad x ^ { \prime } = x + \epsilon v ^ { \frac { 1 } { 2 } } ; \quad v ^ { \prime } = v - \frac { \epsilon } { 2 } \partial _ { x } U ( x ^ { \prime } ) . } \end{array}
+$$
+
+Following Sohl-Dickstein et al. (2014), we write the action of the leapfrog integrator in terms of an operator $\mathbf { L }$ : $\mathbf { L } \boldsymbol { \xi } \triangleq \mathbf { L } ( \boldsymbol { x } , \boldsymbol { v } ) \triangleq ( \boldsymbol { x } ^ { \prime } , \boldsymbol { v } ^ { \prime } )$ , and introduce a momentum flip operator $\mathbf { F }$ : $\mathbf { F } ( x , v ) \triangleq$ $( x , - v )$ . It is important to note two properties of these operators. First, the transformation $\mathbf { F L }$ is an involution, i.e. $\mathbf { F L F L } ( x , v ) = \mathbf { F L } ( x ^ { \prime } , - v ^ { \prime } ) = ( x , v )$ . Second, the transformations from $( x , v )$ to $( x , v ^ { \frac { 1 } { 2 } } )$ , from $( x , v ^ { \frac { 1 } { 2 } } )$ to $( x ^ { \prime } , v ^ { \frac { 1 } { 2 } } )$ , and from $( x ^ { \prime } , v ^ { \frac { 1 } { 2 } } )$ to $( x ^ { \prime } , v ^ { \prime } )$ are all volume-preserving shear transformations i.e., only one of the variables ( $x$ or $v$ ) changes, by an amount determined by the other one. The determinant of the Jacobian, $\left. \frac { \partial [ \mathbf { F } \mathbf { L } \xi ] } { \partial \xi ^ { T } } \right.$ , is thus easy to compute. For vanilla HMC $\begin{array} { r } { \left| \frac { \partial [ \mathbf { F } \mathbf { L } \xi ] } { \partial \xi ^ { T } } \right| = 1 } \end{array}$ , but we will leave it in symbolic form for use in Section 4. The Metropolis-HastingsGreen (Hastings, 1970; Green, 1995) acceptance probability for the HMC proposal is made simple by these two properties, and is
+
+$$
+\begin{array} { r } { A ( \mathbf { F } \mathbf { L } \xi | \xi ) = \operatorname* { m i n } \left( 1 , \frac { p ( \mathbf { F } \mathbf { L } \xi ) } { p ( \xi ) } \left| \frac { \partial [ \mathbf { F } \mathbf { L } \xi ] } { \partial \xi ^ { T } } \right| \right) . } \end{array}
+$$
+
+# 4 L2HMC: TRAINING MCMC SAMPLERS
+
+In this section, we describe our proposed method L2HMC (for ‘Learning To Hamiltonian Monte Carlo’). Given access to only an energy function $U$ (and not samples), L2HMC learns a parametric leapfrog operator $\mathbf { L } _ { \theta }$ over an augmented state space. We begin by describing what desiderata we have for $\mathbf { L } _ { \theta }$ , then go into detail on how we parameterize our sampler. Finally, we conclude this section by describing our training procedure.
+
+# 4.1 AUGMENTING HMC
+
+HMC is a powerful algorithm, but it can still struggle even on very simple problems. For example, a two-dimensional multivariate Gaussian with an ill-conditioned covariance matrix can take arbitrarily long to traverse (even if the covariance is diagonal), whereas it is trivial to sample directly from it. Another problem is that HMC can only move between energy levels via a random walk (Neal, 2011), which leads to slow mixing in some models. Finally, HMC cannot easily traverse low-density zones. For example, given a simple Gaussian mixture model, HMC cannot mix between modes without recourse to additional tricks, as illustrated in Figure 1b. These observations determine the list of desiderata for our learned MCMC kernel: fast mixing, fast burn-in, mixing across energy levels, and mixing between modes.
+
+While pursuing these goals, we must take care to ensure that our proposal operator retains two key features of the leapfrog operator used in HMC: it must be invertible, and the determinant of its Jacobian must be tractable. The leapfrog operator satisfies these properties by ensuring that each sub-update only affects a subset of the variables, and that no sub-update depends nonlinearly on any of the variables being updated. We are free to generalize the leapfrog operator in any way that preserves these properties. In particular, we are free to translate and rescale each sub-update of the leapfrog operator, so long as we are careful to ensure that these translation and scale terms do not depend on the variables being updated.
+
+# 4.1.1 STATE SPACE
+
+As in HMC, we begin by augmenting the current state $x \in \mathbb { R } ^ { n }$ with a continuous momentum variable $v \in \mathbb { R } ^ { n }$ drawn from a standard normal. We also introduce a binary direction variable $d \in \{ - 1 , 1 \}$ , drawn from a uniform distribution. We will denote the complete augmented state as $\xi \triangleq ( x , v , d )$ , with probability density $p ( \xi ) = p ( x ) p ( v ) p ( d )$ . Finally, to each step $t$ of the operator $\mathbf { L } _ { \theta }$ we assign a fixed random binary mask $m ^ { t } \in \{ 0 , 1 \} ^ { n }$ that will determine which variables are affected by each sub-update. We draw $m ^ { t }$ uniformly from the set of binary vectors satisfying $\begin{array} { r } { \sum _ { i = 1 } ^ { n } m _ { i } ^ { t } = \lfloor \frac { n } { 2 } \rfloor } \end{array}$ , that is, half of the entries of $m ^ { t }$ are 0 and half are 1. For convenience, we write $\bar { m } ^ { t } = 1 - m ^ { t }$ and $x _ { m ^ { t } } = x \odot m ^ { t }$ $\odot$ denotes element-wise multiplication, and $\mathbb { 1 }$ the all ones vector).
+
+# 4.1.2 UPDATE STEPS
+
+We now describe the details of our augmented leapfrog integrator $\mathbf { L } _ { \theta }$ , for a single time-step $t$ , and for direction $d = 1$ .
+
+We first update the momenta $v$ . This update can only depend on a subset $\zeta _ { 1 } \triangleq ( x , \partial _ { x } U ( x ) , t )$ of the full state, which excludes $v$ . It takes the form
+
+We have introduced three new functions of $\zeta _ { 1 } \colon T _ { v }$ , $Q _ { v }$ , and $S _ { v }$ . $T _ { v }$ is a translation, $\exp ( Q _ { v } )$ rescales the gradient, and $\exp ( \frac { \epsilon } { 2 } S _ { v } )$ rescales the momentum. The determinant of the Jacobian of this transformation is exp $, \left( \frac { \epsilon } { 2 } \mathbb { 1 } \cdot S _ { v } ( \zeta _ { 1 } ) \right)$ . Note that if $T _ { v }$ , $Q _ { v }$ , and $S _ { v }$ are all zero, then we recover the standard leapfrog momentum update.
+
+We now update $x$ . As hinted above, to make our transformation more expressive, we first update a subset of the coordinates of $x$ , followed by the complementary subset. The first update, which yields $x ^ { \prime }$ and affects only $x _ { m } t$ , depends on the state subset $\zeta _ { 2 } \triangleq ( x _ { \bar { m } ^ { t } } , v , t )$ . Conversely, with $x ^ { \prime }$ defined below, the second update only affects $\boldsymbol { x } _ { \bar { m } ^ { t } } ^ { \prime }$ and depends only on $\zeta _ { 3 } \triangleq ( x _ { m ^ { t } } ^ { \prime } , v , t )$ :
+
+$$
+\begin{array} { l } { { x ^ { \prime } = x _ { \bar { m } ^ { t } } + m ^ { t } \odot [ x \odot \exp ( \epsilon S _ { x } ( \zeta _ { 2 } ) ) + \epsilon ( v ^ { \prime } \odot \exp ( \epsilon Q _ { x } ( \zeta _ { 2 } ) ) + T _ { x } ( \zeta _ { 2 } ) ) ] } } \\ { { x ^ { \prime \prime } = x _ { m ^ { t } } ^ { \prime } + \bar { m } ^ { t } \odot [ x ^ { \prime } \odot \exp ( \epsilon S _ { x } ( \zeta _ { 3 } ) ) + \epsilon ( v ^ { \prime } \odot \exp ( \epsilon Q _ { x } ( \zeta _ { 3 } ) ) + T _ { x } ( \zeta _ { 3 } ) ) ] . } } \end{array}
+$$
+
+Again, $T _ { x }$ is a translation, $\exp ( Q _ { x } )$ rescales the effect of the momenta, $\exp ( \epsilon S _ { x } )$ rescales the positions $x$ , and we recover the original leapfrog position update if $T _ { x } = Q _ { x } = S _ { x } = 0$ . The determinant of the Jacobian of the first transformation is $\bar { \exp { ( \epsilon m ^ { t } \cdot S _ { x } ( \zeta _ { 2 } ) ) } }$ , and the determinant of the Jacobian of the second transformation is $\exp { ( \epsilon \bar { m } ^ { t } \cdot S _ { x } ( \zeta _ { 3 } ) ) }$ .
+
+Finally, we update $v$ again, based on the subset $\zeta _ { 4 } \triangleq ( x ^ { \prime \prime } , \partial _ { x } U ( x ^ { \prime \prime } ) , t )$ :
+
+$$
+\begin{array} { r } { v ^ { \prime \prime } = v ^ { \prime } \odot \exp ( \frac { \epsilon } { 2 } S _ { v } ( \zeta _ { 4 } ) ) - \frac { \epsilon } { 2 } ( \partial _ { x } U ( x ^ { \prime \prime } ) \odot \exp ( \epsilon Q _ { v } ( \zeta _ { 4 } ) ) + T _ { v } ( \zeta _ { 4 } ) ) . } \end{array}
+$$
+
+This update has the same form as the momentum update in equation 4.
+
+To give intuition into these terms, the scaling applied to the momentum can enable, among other things, acceleration in low-density zones, to facilitate mixing between modes. The scaling term applied to the gradient of the energy may allow better conditioning of the energy landscape (e.g., by learning a diagonal inertia tensor), or partial ignoring of the energy gradient for rapidly oscillating energies.
+
+The corresponding integrator for $d = - 1$ is given in Appendix A; it essentially just inverts the updates in equations 4, 5 and 6. For all experiments, the functions $Q , S , T$ are implemented using multi-layer perceptrons, with shared weights. We encode the current time step in the MLP input.
+
+Our leapfrog operator $\mathbf { L } _ { \theta }$ corresponds to running $M$ steps of this modified leapfrog, $\begin{array} { r l } { \mathbf { L } _ { \theta } \boldsymbol { \xi } } & { { } = } \end{array}$ ${ \bf L } _ { \theta } ( x , v , d ) \stackrel {  } { = } ( x ^ { \prime \prime \times M } , v ^ { \prime \prime \times M } , d )$ , and our flip operator $\mathbf { F }$ reverses the direction variable $d$ , $\mathbf { F } \xi =$ $( x , v , - d )$ . Written in terms of these modified operators, our proposal and acceptance probability are identical to those for standard HMC. Note, however, that this parameterization enables learning non-volume-preserving transformations, as the determinant of the Jacobian is a function of $S _ { x }$ and $S _ { v }$ that does not necessarily evaluate to 1. This quantity is derived in Appendix B.
+
+# 4.1.3 MCMC TRANSITIONS
+
+For convenience, we denote by $\mathbf { R }$ an operator that re-samples the momentum and direction. I.e., given $\xi ~ = ~ ( x , v , d )$ , $\mathbf { R } \xi = ( x , v ^ { \prime } , d ^ { \prime } )$ where $v ^ { \prime } \sim \mathcal { N } ( 0 , I ) , d ^ { \prime } \sim \mathcal { U } \left( \{ - 1 , 1 \} \right)$ . Sampling thus consists of alternating application of the $\mathbf { F L } _ { \theta }$ and $\mathbf { R }$ , in the following two steps each of which is a Markov transition that satisfies detailed balance with respect to $p$ :
+
+1. $\boldsymbol { \xi } ^ { \prime } = \mathbf { F } \mathbf { L } _ { \boldsymbol { \theta } } \boldsymbol { \xi }$ with probability $A ( \mathbf { F L } _ { \theta } \xi | \xi )$ (Equation 3), otherwise $\xi ^ { \prime } = \xi$   
+2. $\boldsymbol { \xi } ^ { \prime } = \mathbf { R } \boldsymbol { \xi }$
+
+This parameterization is effectively a generalization of standard HMC as it is non-volume preserving, with learnable parameters, and easily reduces to standard HMC for $Q , S , T = 0$ .
+
+# 4.2 LOSS AND TRAINING PROCEDURE
+
+We need some criterion to train the parameters $\theta$ that control the functions $Q , S$ , and $T$ . We choose a loss designed to reduce mixing time. Specifically, we aim to minimize lag-one autocorrelation. This is equivalent to maximizing expected squared jumped distance (Pasarica & Gelman, 2010). For $\xi , \xi ^ { \prime }$ in the extended state space, we define $\delta ( \xi ^ { \bar { \prime } } , \xi ) \ = \ \delta ( ( x ^ { \prime } , v ^ { \prime } , d ^ { \prime } ) , ( x , v , d ) ) \ = \ | | x - x ^ { \prime } | | _ { 2 } ^ { 2 }$ . Expected squared jumped distance is thus $\mathbb { E } _ { \xi \sim p ( \xi ) } \left[ \delta ( \mathbf { F L } _ { \theta } \xi , \xi ) A ( \mathbf { F L } _ { \theta } \xi | \xi ) \right]$ . However, this loss need not encourage mixing across the entire state space. Indeed, maximizing this objective can lead to regions of state space where almost no mixing occurs, so long as the average squared distance traversed remains high. To optimize both for typical and worst case behavior, we include a reciprocal term in the loss,
+
+$$
+\begin{array} { r } { \ell _ { \lambda } ( \xi , \xi ^ { \prime } , A ( \xi ^ { \prime } | \xi ) ) = \frac { \lambda ^ { 2 } } { \delta ( \xi , \xi ^ { \prime } ) A ( \xi ^ { \prime } | \xi ) } - \frac { \delta ( \xi , \xi ^ { \prime } ) A ( \xi ^ { \prime } | \xi ) } { \lambda ^ { 2 } } , } \end{array}
+$$
+
+where $\lambda$ is a scale parameter, capturing the characteristic length scale of the problem. The second term encourages typical moves to be large, while the first term strongly penalizes the sampler if it is ever in a state where it cannot move effectively – $\delta ( \xi , \xi ^ { \prime } )$ being small resulting in a large loss value. We train our sampler by minimizing this loss over both the target distribution and initialization distribution. Formally, given an initial distribution $\pi _ { 0 }$ over $\mathcal { X }$ , we define $q ( \xi ) = \pi _ { 0 } ( x ) \mathcal { N } ( v ; 0 , I ) p ( d )$ , and minimize
+
+$$
+\begin{array} { r } { \mathcal { L } ( \boldsymbol { \theta } ) \triangleq \mathbb { E } _ { p ( \boldsymbol { \xi } ) } \left[ \ell _ { \lambda } ( \boldsymbol { \xi } , \mathbf { F } \mathbf { L } _ { \boldsymbol { \theta } } \boldsymbol { \xi } , A ( \mathbf { F } \mathbf { L } _ { \boldsymbol { \theta } } \boldsymbol { \xi } | \boldsymbol { \xi } ) ) \right] + \lambda _ { b } \mathbb { E } _ { q ( \boldsymbol { \xi } ) } \left[ \ell _ { \lambda } ( \boldsymbol { \xi } , \mathbf { F } \mathbf { L } _ { \boldsymbol { \theta } } \boldsymbol { \xi } , A ( \mathbf { F } \mathbf { L } _ { \boldsymbol { \theta } } \boldsymbol { \xi } | \boldsymbol { \xi } ) ) \right] . } \end{array}
+$$
+
+The first term of this loss encourages mixing as it considers our operator applied on draws from the distribution; the second term rewards fast burn-in; $\lambda _ { b }$ controls the strength of the ‘burn-in’ regularization. Given this loss, we exactly describe our training procedure in Algorithm 1. It is important to note that each training iteration can be done with only one pass through the network and can be efficiently batched. We further emphasize that this training procedure can be applied to any learnable operator whose Jacobian’s determinant is tractable, making it a general framework for training MCMC proposals.
+
+# Algorithm 1 Training L2HMC
+
+Input: Energy function $U : \mathcal { X }  \mathbb { R }$ and its gradient $\nabla _ { x } U : x  x$ , initial distribution over   
+the augmented state space $q$ , number of iterations $n _ { \mathrm { i t e r s } }$ , number of leapfrogs $M$ , learning rate   
+schedule (αt)t≤n , batch size $N$ , scale parameter $\lambda$ and regularization strength $\lambda _ { b }$ .   
+Initialize the parameters of the sampler $\theta$ .   
+Initialize $\{ \xi _ { p } ^ { ( i ) } \} _ { i \le N }$ from $q ( \xi )$ .   
+for $t = 0$ to $n _ { \mathrm { i t e r s } } - 1$ do Sample a minibatch $\{ \xi _ { q } ^ { ( i ) } \} _ { i \leq N }$ from $q ( \xi )$ . $\mathcal { L }  0$ for r $\begin{array} { r l } & { \xi _ { p } ^ { ( i ) } \gets \mathbf { R } \xi _ { p } ^ { ( i ) } } \\ & { \mathcal { L } \gets \mathcal { L } + \ell _ { \lambda } \left( \xi _ { p } ^ { ( i ) } , \mathbf { F L } _ { \theta } \xi _ { p } ^ { ( i ) } , A ( \mathbf { F L } _ { \theta } \xi _ { p } ^ { ( i ) } | \xi _ { p } ^ { ( i ) } ) \right) + \lambda _ { b } \ell _ { \lambda } \left( \xi _ { q } ^ { ( i ) } , \mathbf { F L } _ { \theta } \xi _ { q } ^ { ( i ) } , A ( \mathbf { F L } _ { \theta } \xi _ { q } ^ { ( i ) } | \xi _ { q } ^ { ( i ) } ) \right) } \\ & { } \end{array}$ $i = 1$ to $N$ do $\begin{array} { r } { \xi _ { p } ^ { ( i ) }  \mathbf { F L } _ { \theta } \xi _ { p } ^ { ( i ) } } \end{array}$ with probability $A ( \mathbf { F L } _ { \theta } \xi _ { p } ^ { ( i ) } | \xi _ { p } ^ { ( i ) } )$ . end for θ  θ  α t θ   
+end for
+
+# 5 EXPERIMENTS
+
+We present an empirical evaluation of our trained sampler on a diverse set of energy functions. We first present results on a collection of toy distributions capturing common pathologies of energy landscapes, followed by results on a task from machine learning: maximum-likelihood training of deep generative models. For each, we compare against HMC with well-tuned step length and show significant gains in mixing time. Code implementing our algorithm is available online1.
+
+# 5.1 VARIED COLLECTION OF ENERGY FUNCTIONS
+
+We evaluate our L2HMC sampler on a diverse collection of energy functions, each posing different challenges for standard HMC.
+
+Ill-Conditioned Gaussian (ICG): Gaussian distribution with diagonal covariance spaced loglinearly between $1 0 ^ { - 2 }$ and $1 0 ^ { 2 }$ . This demonstrates that L2HMC can learn a diagonal inertia tensor.
+
+Strongly correlated Gaussian (SCG): We rotate a diagonal Gaussian with variances $[ 1 0 ^ { 2 } , 1 0 ^ { - 2 } ]$ by $\frac { \pi } { 4 }$ . This is an extreme version of an example from Neal (2011). This problem shows that, although our parametric sampler only applies element-wise transformations, it can adapt to structure which is not axis-aligned.
+
+Mixture of Gaussians (MoG): Mixture of two isotropic Gaussians with $\sigma ^ { 2 } = 0 . 1$ , and centroids separated by distance 4. The means are thus about 12 standard deviations apart, making it almost impossible for HMC to mix between modes.
+
+Rough Well: Similar to an example from Sohl-Dickstein et al. (2014), for a given $\eta > 0 , U ( x ) =$ $\begin{array} { r } { \frac { 1 } { 2 } x ^ { T } \overset { \smile } { x } + \eta \sum _ { i } \cos ( \frac { x _ { i } } { \eta } ) } \end{array}$ . For small $\eta$ the energy itself is altered negligibly, but its gradient is perturbed by a high frequency noise oscillating between $- 1$ and 1. In our experiments, we choose $\eta = 1 0 ^ { - 2 }$ .
+
+For each of these distributions, we compare against HMC with the same number of leapfrog steps and a well-tuned step-size. To compare mixing time, we plot auto-correlation for each method and report effective sample size (ESS). We compute those quantities in the same way as Sohl-Dickstein et al. (2014). We observe that samplers trained with L2HMC show greatly improved autocorrelation and ESS on the presented tasks, providing more than $1 0 6 \times$ improved ESS on the SCG task. In addition, for the MoG, we show that L2HMC can easily mix between modes while standard HMC gets stuck in a mode, unable to traverse the low density zone. Experimental details, as well as a comparison with LAHMC (Sohl-Dickstein et al., 2014), are shown in Appendix C.
+
+![](images/e878bce92e8dd48bdb837822419a4ea3132437ffdaebbcd93f07f493cdac4546.jpg)  
+Figure 1: L2HMC mixes faster than well-tuned HMC, and than A-NICE-MC, on a collection of toy distributions.
+
+Comparison to A-NICE-MC (Song et al., 2017) In addition to the well known challenges associated with adversarial training (Arjovsky et al., 2017), we note that parameterization using a volume-preserving operator can dramatically fail on simple energy landscapes. We build off of the mog2 experiment presented in (Song et al., 2017), which is a 2-d mixture of isotropic Gaussians separated by a distance of 10 with variances 0.5. We consider that setup but increase the ratio of variances: $\dot { \sigma } _ { 1 } ^ { 2 } = 3 , \sigma _ { 2 } ^ { 2 } = 0 . 0 5$ . We show in Figure 1d sample chains trained with L2HMC and A-NICE-MC; A-NICE-MC cannot effectively mix between the two modes as only a fraction of the volume of the large mode can be mapped to the small one, making it highly improbable to traverse. This is also an issue for HMC. On the other hand, L2HMC can both traverse the low-density region between modes, and map a larger volume in the left mode to a smaller volume in the right mode. It is important to note that the distance between both clusters is less than in the mog2 case, and it is thus a good diagnostic of the shortcomings of volume-preserving transformations.
+
+# 5.2 LATENT-VARIABLE GENERATIVE MODEL
+
+We apply our learned sampler to the task of training, and sampling from the posterior of, a latentvariable generative model. The model consists of a latent variable $z \sim p ( z )$ , where we choose $p ( z ) = \breve { \mathscr { N } } ( z ; 0 , I )$ , and a conditional distribution $p ( x | z )$ which generates the image $x$ . Given a family of parametric ‘decoders’ $\{ z \mapsto p ( x | z ; \phi ) , \phi \in \Phi \}$ , and a set of samples $\mathcal { D } = \{ x ^ { ( i ) } \} _ { i \leq N }$ training involves finding $\begin{array} { r } { \phi ^ { * } = \arg \operatorname* { m a x } _ { \phi \in \Phi } p ( \mathcal { D } ; \phi ) } \end{array}$ . However, the log-likelihood is intractable as $\begin{array} { r } { p ( x ; \boldsymbol { \phi } ) = \int p ( x | \boldsymbol { z } ; \boldsymbol { \phi } ) p ( \boldsymbol { z } ) \mathrm { d } \boldsymbol { z } } \end{array}$ . To remedy that problem, Kingma $\&$ Welling (2013) proposed jointly training an approximate posterior $q _ { \psi }$ that maximizes a tractable lower-bound on the log-likelihood:
+
+![](images/250475de256c4eebae15fc4fa637a5547873059d01bec521d1802c331ccf79c1.jpg)  
+Figure 2: Training and held-out log-likelihood for models trained with L2HMC, HMC, and the ELBO (VAE).
+
+$$
+\mathcal { L } _ { \mathrm { E L B O } } ( x , \phi , \psi ) = \mathbb { E } _ { q _ { \psi } ( z | x ) } \left[ p ( x | z ; \phi ) \right] - \mathrm { K L } ( q _ { \psi } ( z | x ) | | p ( z ) ) \leq p ( x ) ,
+$$
+
+where $q _ { \psi } ( z | x )$ is a tractable conditional distribution with parameters $\psi$ , typically parameterized by a neural network. Recently, to improve upon well-known pitfalls like over-pruning (Burda et al., 2015) of the VAE, Hoffman (2017) proposed HMC-DLGM. For a data sample $x ^ { ( i ) }$ , after obtaining a sample from the approximate posterior $q _ { \psi } ( \cdot | x ^ { ( i ) } )$ , Hoffman (2017) runs a MCMC algorithm with energy function $U ( z , x ^ { ( i ) } ) = - \log p ( z ) - \log p ( x ^ { ( i ) } | z ; \phi )$ to obtain a more exact posterior sample from $p ( \boldsymbol { z } | \boldsymbol { x } ^ { ( i ) } ; \boldsymbol { \phi } )$ . Given that better posterior sample $z ^ { \prime }$ , the algorithm maximizes $\log p ( x ^ { ( i ) } | z ^ { \prime } ; \phi )$ .
+
+To show the benefits of L2HMC, we borrow the method from Hoffman (2017), but replace HMC by jointly training an L2HMC sampler to improve the efficiency of the posterior sampling. We call this model L2HMC-DLGM. A diagram of our model and a formal description of our training procedure are presented in Appendix D. We define, for $\xi = \{ z , v , d \} , r ( \xi | x ; \psi ) \triangleq$ $q _ { \psi } ( z | x ) \mathcal { N } ( v ; \bar { 0 , I } ) \mathcal { U } ( d ; \{ - 1 , \bar { 1 } \} )$ .
+
+In the subsequent sections, we compare our method to the standard VAE model from Kingma & Welling (2013) and HMC-DGLM from Hoffman (2017). It is important to note that, since our sampler is trained jointly with $p _ { \phi }$ and $q _ { \psi }$ , it performs exactly the same number of gradient computations of the energy function as HMC. We first show that training a latent variable generative model with L2HMC results in better generative models both qualitatively and quantitatively. We then show that our improved sampler enables a more expressive, non-Gaussian, posterior.
+
+Implementation details: Our decoder $( p _ { \phi } )$ is a neural network with 2 fully connected layers, with 1024 units each and softplus non-linearities, and outputs Bernoulli activation probabilities for each pixel. The encoder $( q _ { \psi } )$ has the same architecture, returning mean and variance for the approximate posterior. Our model was trained for 300 epochs with Adam (Kingma & Ba, 2014) and a learning rate $\alpha = 1 0 ^ { - 3 }$ . All experiments were done on the dynamically binarized MNIST dataset (LeCun).
+
+# 5.2.1 SAMPLE QUALITY AND DATA LIKELIHOOD
+
+We first present samples from decoders trained with L2HMC, HMC and the ELBO (i.e. vanilla VAE). Although higher log likelihood does not necessarily correspond to better samples (Theis et al., 2015), we can see in Figure 5, shown in the Appendix, that the decoder trained with L2HMC generates sharper samples than the compared methods.
+
+We now compare our method to HMC in terms of log-likelihood of the data. As we previously stated, the marginal likelihood of a data point $x \in \mathcal { X }$ is not tractable as it requires integrating $p ( x , z )$ over a high-dimensional space. However, we can estimate it using annealed importance sampling (AIS; Neal (2001)). Following Wu et al. (2016), we evaluate our generative models on both training and held-out data. In Figure 2, we plot the data’s log-likelihood against the number of gradient computation steps for both HMC-DGLM and L2HMC-DGLM. We can see that for a similar number of gradient computations, L2HMC-DGLM achieves higher likelihood for both training and held-out data. This is a strong indication that L2HMC provides significantly better posterior samples.
+
+![](images/fa42f98b9e8fda6e4c48a55741ecf4bec0e430aa2379cfc10ac8d84350687b92.jpg)
+
+(a) Block Gibbs inpainting of the top half of an MNIST digit, using (top) L2HMC as a posterior sampler, and (bottom) $q _ { \psi }$ as a posterior sampler.
+
+![](images/3b5a148d0cd5e54e8a2a908b2b63c8ebc00143ad9d41f371e71810f20e32da5a.jpg)  
+(b) Non-Gaussian posterior   
+Figure 3: Demonstrations of the value of a more expressive posterior approximation.
+
+# 5.2.2 INCREASED EXPRESSIVITY OF THE POSTERIOR
+
+In the standard VAE framework, approximate posteriors are often parametrized by a Gaussian, thus making a strong assumption of uni-modality. In this section, we show that using L2HMC to sample from the posterior enables learning of a richer posterior landscape.
+
+Block Gibbs Sampling To highlight our ability to capture more expressive posteriors, we in-paint the top of an image using Block Gibbs Sampling using the approximate posterior or L2HMC. Formally, let $x _ { 0 }$ be the starting image. We denote top or bottom-half pixels as $x _ { 0 } ^ { \mathrm { t o p } }$ and $x _ { 0 } ^ { \mathrm { b o t t o m } }$ . At each step $t$ , we sample $z ^ { ( t ) } \sim p ( z | x _ { t } ; \theta )$ , sample $\tilde { x } \sim p ( x | z _ { t } ; \theta )$ . We then set $x _ { t + 1 } ^ { \mathrm { t o p } } = \tilde { x } ^ { \mathrm { t o p } }$ and $x _ { t + 1 } ^ { \mathrm { b o t t o m } } = x _ { 0 } ^ { \mathrm { b o t t o m } }$ . We compare the results obtained by sampling from ior) vs. our trained sampler. The results are reported i $p ( z | x ; \theta )$ using a. We $q _ { \psi }$ (i.e. the see that L2HMC easily mixes between modes (3, 5, 8, and plausibly 9 in the figure) while the approximate posterior gets stuck on the same reconstructed digit (3 in the figure).
+
+Visualization of the posterior After training a decoder with L2HMC, we randomly choose an element $x _ { 0 } \in \mathcal { D }$ and run 512 parallel L2HMC chains for 20, 000 Metropolis-Hastings steps. We then find the direction of highest variance, project the samples along that direction and show a histogram in Figure 3b. This plot shows non-Gaussianity in the latent space for the posterior. Using our improved sampler enables the decoder to make use of a more expressive posterior, and enables the encoder to sample from this non-Gaussian posterior.
+
+# 6 FUTURE WORK
+
+The loss in Section 4.2 targets lag-one autocorrelation. It should be possible to extend this to also target lag-two and higher autocorrelations. It should also be possible to extend this loss to reward fast decay in the autocorrelation of other statistics of the samples, for instance the sample energy as well as the sample position. These additional statistics could also include learned statistics of the samples, combining benefits of the adversarial approach of (Song et al., 2017) with the current work.
+
+Our learned generalization of HMC should prove complementary to several other research directions related to HMC. It would be interesting to explore combining our work with the use of HMC in a minibatch setting (Chen et al., 2014); with shadow Hamiltonians (Izaguirre & Hampton, 2004); with gradient pre-conditioning approaches similar to those used in Riemannian HMC (Girolami et al., 2009; Betancourt, 2013); with the use of alternative HMC accept-reject rules (Sohl-Dickstein et al., 2014; Berger et al., 2015); with the use of non-canonical Hamiltonian dynamics (Tripuraneni et al., 2016); with variants of AIS adapted to HMC proposals (Sohl-Dickstein & Culpepper, 2012); with the extension of HMC to discrete state spaces (Zhang et al., 2012); and with the use of alternative Hamiltonian integrators (Creutz & Gocksch, 1989; Chao et al., 2015).
+
+Finally, our work is also complementary to other methods not utilizing gradient information. For example, we could incorporate the intuition behind Multiple Try Metropolis schemes (Martino & Read, 2013) by having several parametric operators and training each one when used. In addition, one could draw inspiration from the adaptive literature (Haario et al., 2001; Andrieu & Thoms, 2008) or component-wise strategies (Gilks & Wild, 1992).
+
+# 7 CONCLUSION
+
+In this work, we presented a general method to train expressive MCMC kernels parameterized with deep neural networks. Given a target distribution $p$ , analytically known up to a constant, our method provides a fast-mixing sampler, able to efficiently explore the state space. Our hope is that our method can be utilized in a “black-box” manner, in domains where sampling constitutes a huge bottleneck such as protein foldings (Schutte et al., 1999) or physics simulations (Olsson, 1995). ¨
+
+# ACKNOWLEDGMENTS
+
+We would like to thank Ben Poole, Aditya Grover, David Belanger, and Colin Raffel for insightful comments on the draft, Mohammad Norouzi for support and encouragement launching the project, and Jiaming Song for discussions and help running A-NICE-MC.
+
+# REFERENCES
+
+Christophe Andrieu and Johannes Thoms. A tutorial on adaptive MCMC. Statistics and computing, 18(4): 343–373, 2008.
+
+Christophe Andrieu, Nando De Freitas, Arnaud Doucet, and Michael I Jordan. An introduction to MCMC for machine learning. Machine learning, 50(1-2):5–43, 2003.
+
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein GAN. ´ arXiv preprint arXiv:1701.07875, 2017.
+
+Yoshua Bengio, Eric Laufer, Guillaume Alain, and Jason Yosinski. Deep generative stochastic networks trainable by backprop. In International Conference on Machine Learning, pp. 226–234, 2014.
+
+Charles H Bennett. Mass tensor molecular dynamics. Journal of Computational Physics, 19(3):267–279, 1975.
+
+Andrew B Berger, Mayur Mudigonda, Michael R DeWeese, and Jascha Sohl-Dickstein. A Markov jump process for more efficient Hamiltonian Monte Carlo. arXiv preprint arXiv:1509.03808, 2015.
+
+Michael Betancourt. A general metric for Riemannian manifold Hamiltonian Monte Carlo. In Geometric science of information, pp. 327–334. Springer, 2013.
+
+Yuri Burda, Roger Grosse, and Ruslan Salakhutdinov. Importance weighted autoencoders. arXiv preprint arXiv:1509.00519, 2015.
+
+Wei-Lun Chao, Justin Solomon, Dominik Michels, and Fei Sha. Exponential integration for Hamiltonian Monte Carlo. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1142–1151, 2015.
+
+Tianqi Chen, Emily Fox, and Carlos Guestrin. Stochastic gradient Hamiltonian Monte Carlo. In International Conference on Machine Learning, pp. 1683–1691, 2014.
+
+Michael Creutz and Andreas Gocksch. Higher-order hybrid Monte Carlo algorithms. Physical Review Letters, 63(1):9, 1989.
+
+Laurent Dinh, Jascha Sohl-Dickstein, and Samy Bengio. Density estimation using real NVP. arXiv preprint arXiv:1605.08803, 2016.
+
+Simon Duane, Anthony D Kennedy, Brian J Pendleton, and Duncan Roweth. Hybrid Monte Carlo. Physics letters B, 195(2):216–222, 1987.
+
+Walter R Gilks and Pascal Wild. Adaptive rejection sampling for gibbs sampling. Applied Statistics, pp. 337–348, 1992.
+
+Mark Girolami and Ben Calderhead. Riemann manifold Langevin and Hamiltonian Monte Carlo methods. Journal of the Royal Statistical Society: Series B (Statistical Methodology), 73(2):123–214, 2011.
+
+Mark Girolami, Ben Calderhead, and Siu A Chin. Riemannian manifold Hamiltonian Monte Carlo. arXiv preprint arXiv:0907.1100, 2009.
+
+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.
+
+Peter J Green. Reversible jump markov chain monte carlo computation and bayesian model determination. Biometrika, 82(4):711–732, 1995.
+
+Heikki Haario, Eero Saksman, Johanna Tamminen, et al. An adaptive metropolis algorithm. Bernoulli, 7(2): 223–242, 2001.
+
+Ernst Hairer, Christian Lubich, and Gerhard Wanner. Geometric numerical integration illustrated by the Stormer–Verlet method. ¨ Acta numerica, 12:399–450, 2003.
+
+W Keith Hastings. Monte Carlo sampling methods using Markov chains and their applications. Biometrika, 57 (1):97–109, 1970.
+
+Matthew D Hoffman. Learning deep latent Gaussian models with Markov chain Monte Carlo. In International Conference on Machine Learning, pp. 1510–1519, 2017.
+
+Matthew D Hoffman and Andrew Gelman. The no-U-turn sampler: adaptively setting path lengths in Hamiltonian Monte Carlo. Journal of Machine Learning Research, 15(1):1593–1623, 2014.
+
+Li Huang and Lei Wang. Accelerated monte carlo simulations with restricted boltzmann machines. Physical Review B, 95(3):035105, 2017.
+
+Akihisa Ichiki and Masayuki Ohzeki. Violation of detailed balance accelerates relaxation. Physical Review E, 88(2):020101, 2013.
+
+Jesus A Izaguirre and Scott S Hampton. Shadow hybrid Monte Carlo: an efficient propagator in phase space of ´ macromolecules. Journal of Computational Physics, 200(2):581–604, 2004.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational Bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Yann LeCun. The MNIST database of handwritten digits. http://yann. lecun. com/exdb/mnist/.
+
+Benedict Leimkuhler and Sebastian Reich. Simulating Hamiltonian dynamics, volume 14. Cambridge University Press, 2004.
+
+Junwei Liu, Yang Qi, Zi Yang Meng, and Liang Fu. Self-learning monte carlo method. Physical Review B, 95 (4):041101, 2017.
+
+David JC MacKay. Information theory, inference and learning algorithms. Cambridge university press, 2003.
+
+Luca Martino and Jesse Read. On the flexibility of the design of multiple try metropolis schemes. Computational Statistics, 28(6):2797–2823, 2013.
+
+Radford M Neal. Probabilistic inference using Markov chain Monte Carlo methods. 1993.
+
+Radford M Neal. Sampling from multimodal distributions using tempered transitions. Statistics and computing, 6(4):353–366, 1996.
+
+Radford M Neal. Annealed importance sampling. Statistics and computing, 11(2):125–139, 2001.
+
+Radford M Neal. MCMC using Hamiltonian dynamics. Handbook of Markov Chain Monte Carlo, 2(11), 2011.
+
+Peter Olsson. Two phase transitions in the fully frustrated XY model. Physical review letters, 75(14):2758, 1995.
+
+Cristian Pasarica and Andrew Gelman. Adaptively scaling the Metropolis algorithm using expected squared jumped distance. Statistica Sinica, pp. 343–364, 2010.
+
+Danilo Jimenez Rezende, Shakir Mohamed, and Daan Wierstra. Stochastic backpropagation and approximate inference in deep generative models. In ICML, 2014.
+
+Tim Salimans, Diederik Kingma, and Max Welling. Markov chain Monte Carlo and variational inference: Bridging the gap. In Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1218–1226, 2015.
+
+Ch Schutte, Alexander Fischer, Wilhelm Huisinga, and Peter Deuflhard. A direct approach to conformational¨ dynamics based on hybrid Monte Carlo. Journal of Computational Physics, 151(1):146–168, 1999.
+
+Dino Sejdinovic, Heiko Strathmann, Maria Lomeli Garcia, Christophe Andrieu, and Arthur Gretton. Kernel adaptive metropolis-hastings. In International Conference on Machine Learning, pp. 1665–1673, 2014.   
+Jascha Sohl-Dickstein and Benjamin J Culpepper. Hamiltonian annealed importance sampling for partition function estimation. arXiv preprint arXiv:1205.1925, 2012.   
+Jascha Sohl-Dickstein, Mayur Mudigonda, and Michael R DeWeese. Hamiltonian Monte Carlo without detailed balance. pp. 719–726, 2014.   
+Jascha Sohl-Dickstein, Eric A Weiss, Niru Maheswaranathan, and Surya Ganguli. Deep unsupervised learning using nonequilibrium thermodynamics. arXiv preprint arXiv:1503.03585, 2015.   
+Jiaming Song, Shengjia Zhao, and Stefano Ermon. A-nice-mc: Adversarial training for mcmc. In Advances in Neural Information Processing Systems, pp. 5146–5156, 2017.   
+Heiko Strathmann, Dino Sejdinovic, Samuel Livingstone, Zoltan Szabo, and Arthur Gretton. Gradient-free hamiltonian monte carlo with efficient kernel exponential families. In Advances in Neural Information Processing Systems, pp. 955–963, 2015.   
+Lucas Theis, Aaron van den Oord, and Matthias Bethge. A note on the evaluation of generative models. ¨ arXiv preprint arXiv:1511.01844, 2015.   
+Nilesh Tripuraneni, Mark Rowland, Zoubin Ghahramani, and Richard Turner. Magnetic Hamiltonian Monte Carlo. arXiv preprint arXiv:1607.02738, 2016.   
+Lei Wang. Can boltzmann machines discover cluster updates? arXiv preprint arXiv:1702.08586, 2017.   
+Yuhuai Wu, Yuri Burda, Ruslan Salakhutdinov, and Roger Grosse. On the quantitative analysis of decoderbased generative models. arXiv preprint arXiv:1611.04273, 2016.   
+Yichuan Zhang, Zoubin Ghahramani, Amos J Storkey, and Charles A Sutton. Continuous relaxations for discrete hamiltonian monte carlo. In Advances in Neural Information Processing Systems, pp. 3194–3202, 2012.
+
+# Appendix
+
+# A REVERSE LEAPFROG OPERATOR
+
+Let $\xi = \{ x , v , d \}$ in the extended state space with $d = - 1$ . Here, we describe the leapfrog updates for a single time step $t$ , this consists of inverting the equations presented in the corresponding section.
+
+Let $\zeta _ { 1 } = \{ x , v , t \}$ , we have:
+
+$$
+v ^ { \prime } = \left[ v + \frac { \epsilon } { 2 } \left( \partial _ { x } U ( x ) \odot \exp ( \epsilon Q _ { v } ( \zeta _ { 1 } ) ) + T _ { v } ( \zeta _ { 1 } ) \right) \right] \odot \exp ( - S _ { v } ( \zeta _ { 1 } ) ) .
+$$
+
+With the notation from Section 4, let $\zeta _ { 2 } \triangleq \{ x _ { m ^ { t } } , v , t \}$
+
+$$
+x ^ { \prime } = x _ { m ^ { t } } + \bar { m } ^ { t } \odot [ ( x - \epsilon ( \exp ( \epsilon Q _ { x } ( \zeta _ { 2 } ) ) \odot v ^ { \prime } + T _ { x } ( \zeta _ { 2 } ) ) ] \odot \exp ( - \epsilon S _ { v } ( \zeta _ { 2 } ) ) .
+$$
+
+Let us denote $\zeta _ { 3 } \triangleq \{ x _ { \bar { m } ^ { t } } ^ { \prime } , v , t \}$ :
+
+$$
+x ^ { \prime \prime } = x _ { \bar { m } ^ { t } } + m ^ { t } \odot [ ( x ^ { \prime } - \epsilon ( \exp ( \epsilon Q _ { x } ( \zeta _ { 3 } ) ) \odot v ^ { \prime } + T _ { x } ( \zeta _ { 3 } ) ) ] \odot \exp ( - \epsilon S _ { v } ( \zeta _ { 3 } ) ) .
+$$
+
+Finally, the last update, with $\zeta _ { 4 } \triangleq \{ x ^ { \prime \prime } , \partial _ { x } U ( x ^ { \prime \prime } ) , t \}$ :
+
+$$
+v ^ { \prime } = \left[ v + { \frac { \epsilon } { 2 } } \left( \partial _ { x } U ( x ^ { \prime \prime } ) \odot \exp ( \epsilon Q _ { v } ( \zeta _ { 4 } ) ) + T _ { v } ( \zeta _ { 4 } ) \right) \right] \odot \exp ( - S _ { v } ( \zeta _ { 4 } ) ) .
+$$
+
+It is important to note that to invert $\mathbf { L } _ { \theta }$ , these steps should be ran for $t$ from $M$ to 1.
+
+# B DETERMINANT OF THE JACOBIAN
+
+Given the derivations (and notations) from Section 4, for the forward operator $\mathbf { L } _ { \theta }$ , we can immediately compute the Jacobian:
+
+$$
+\log \left| \frac { \partial [ \mathbf { F } \mathbf { L } _ { \theta } \boldsymbol { \xi } ] } { \partial \boldsymbol { \xi } ^ { T } } \right| = d \sum _ { t \leq M } \left[ \frac { \epsilon } { 2 } \mathbf { 1 } \cdot S _ { v } ( \boldsymbol { \zeta } _ { 1 } ^ { t } ) + \epsilon m ^ { t } \cdot S _ { x } ( \boldsymbol { \zeta } _ { 2 } ^ { t } ) + \epsilon \bar { m } ^ { t } \cdot S _ { x } ( \boldsymbol { \zeta } _ { 3 } ^ { t } ) + \frac { \epsilon } { 2 } \mathbf { 1 } \cdot S _ { v } ( \boldsymbol { \zeta } _ { 4 } ^ { t } ) \right] .
+$$
+
+Where $\zeta _ { i } ^ { t }$ denotes the intermediary variable $\zeta _ { i }$ at time step $t$ and $d$ is the direction of $\xi$ i.e. $\xi =$   
+$\{ x , v , d \}$ .
+
+# C EXPERIMENTAL DETAILS OF SECTION 5
+
+# C.1 IMPLEMENTATION DETAILS
+
+First of all, we keep separate parameters for the network responsible for updating $v$ and those updating $x$ . The architectures are the same. Let us take the example of $Q _ { v } , S _ { v } , T _ { v }$ . The time step $t$ is given as input to the MLP, encoded as $\begin{array} { r } { \tau ( t ) = ( \cos ( \frac { 2 \pi t } { M } ) , \sin ( \frac { 2 \pi { \hat { t } } } { M } ) ) } \end{array}$ . $\sigma ( \cdot )$ denotes the ReLU non-linearity.
+
+For $n _ { h }$ hidden units per layer:
+
+• We first compute $h _ { 1 } = \sigma ( W _ { 1 } x + W _ { 2 } v + W _ { 3 } \tau ( t ) + b ) ( h \in \mathbb { R } ^ { n _ { h } } ) .$ · $h _ { 2 } = \sigma ( W _ { 4 } h + b _ { 4 } ) \in \mathbb { R } ^ { n _ { h } }$ • $S _ { v } = \lambda _ { s } \mathtt { t a n h } ( W _ { s } h _ { 2 } + b _ { s } ) , Q _ { v } = \lambda _ { q } \mathtt { t a n h } ( W _ { q } h _ { 2 } + b _ { q } ) , T _ { v } = W _ { t } h _ { 2 } + b _ { t } .$
+
+In Section 5.1, the $Q , S , T$ are neural networks with 2 hidden layers with 10 (100 for the 50-d ICG) units and ReLU non-linearities. We train with Adam (Kingma & Ba, 2014) and a learning rate $\alpha = 1 0 ^ { - 3 }$ . We train for 5, 000 iterations with a batch size of 200.
+
+$\lambda _ { b }$ was set to 0 for ICG and SCG and to 1 for MoG and Rough Well. For the MoG tasks, we train our sampler with a temperature parameter that we continuously anneal; we evaluate the trained sampler without using temperature.
+
+![](images/ce0d3b31ad5969a1d38e2d717519f244a5cf9175ca9b22c578fb2f7627737684.jpg)  
+Figure 4: Diagram of our L2HMC-DGLM model. Nodes are functions of their parents. Round nodes are deterministic, diamond nodes are stochastic and the doubly-circled node is observed.
+
+# C.2 AUTO-CORRELATION AND ESS
+
+Let $( x _ { \tau } ) _ { \tau \leq T }$ be a set of correlated samples converging to the distribution $p$ with mean $\mu$ and covariance $\Sigma$ . We define auto-correlation at time $t$ as:
+
+$$
+\rho _ { t } \triangleq \frac { 1 } { \mathrm { T r a c e } ( \Sigma ) ( T - t ) } \sum _ { \tau \leq T - t - 1 } ( x _ { \tau } - \mu ) ^ { T } ( x _ { \tau + t } - \mu ) .
+$$
+
+We can now define effective sample size (ESS) as:
+
+$$
+\mathrm { E S S } \left( ( x _ { \tau } ) _ { \tau \leq T } \right) \triangleq \frac { 1 } { 1 + 2 \sum _ { t } \rho _ { t } } .
+$$
+
+Similar to Hoffman & Gelman (2014), we truncate the sum when the auto-correlation goes below 0.05.
+
+# C.3 COMPARISON WITH LAHMC
+
+We compare our trained sampler with LAHMC (Sohl-Dickstein et al., 2014). Results are reported in Table 1. L2HMC largely outperforms LAHMC on all task. LAHMC is also unable to mix between modes for the MoG task. We also note that L2HMC could be easily combined with LAHMC, by replacing the leapfrog integrator of LAHMC with the learned one of L2HMC.
+
+Table 1: ESS for a fixed number of gradient evaluations.   
+
+<table><tr><td>Distribution</td><td>Gradient Evaluations</td><td>ESS-L2HMC</td><td>ESS-LAHMC</td><td>Ratio</td></tr><tr><td>50-d ICG</td><td>2000</td><td>156.6</td><td>21.4</td><td>7.3</td></tr><tr><td>Rough Well</td><td>200</td><td>12.5</td><td>8.6</td><td>1.5</td></tr><tr><td>2-d SCG</td><td>5000</td><td>116</td><td>16.7</td><td>14.9</td></tr><tr><td>MoG</td><td>20,000</td><td>65.0</td><td>&lt;0.53</td><td>&gt; 123.5</td></tr></table>
+
+# D L2HMC-DGLM
+
+# D.1 TRAINING ALGORITHM
+
+In this section, we present our training algorithm as well as a diagram explaining L2HMC-DGLM. For conciseness, given our operator $\mathbf { L } _ { \theta }$ , we denote by $\mathbf { K } _ { \theta } ( \cdot | x )$ the distribution over next state given sampling of a momentum and direction and the Metropolis-Hastings step.
+
+# D.2 IMPLEMENTATION DETAILS OF L2HMC-DGLM
+
+Similar to our L2HMC training on unconditional sampling, we share weights across $Q , S$ and $T$ . In addition, the auxiliary variable $x$ (here the image from MNIST) is first passed through a 2-layer neural network, with softplus non-linearities and 512 hidden units. This input is given to both
+
+# Algorithm 2 L2HMC for latent variable generative models
+
+Input: dataset $\mathcal { D }$ , number of iterations $n _ { \mathrm { i t e r s } }$ , number of Metropolis-Hastings step $J$ , number of   
+leapfrogs M , and learning rate schedule (αt)t≤niters .   
+Randomly initialize the decoder’s parameters $\phi$ and the approximate posterior $\psi$ . Initialize the   
+parameters of the sampler $\theta$ with $M$ leapfrog steps.   
+for $t = 0$ to $n _ { \mathrm { i t e r s } } - 1$ do Randomly sample a minibatch $\boldsymbol { B }$ from the dataset $\mathcal { D }$ . $\mathcal { L } _ { \mathrm { E L B O } } , \mathcal { L } _ { \mathrm { S a m p l e r } } , \mathcal { L } _ { \mathrm { D e c o d e r } }  0$ for $\boldsymbol { x } ^ { ( b ) } \in B \mathrm { d } \mathbf { 0 }$ ∈Sample $\xi _ { 0 } ^ { ( b ) } \sim r ( \cdot | x ^ { ( b ) } ; \psi )$ . $\mathcal { L } _ { \mathrm { E L B O } }  p ( x ^ { ( b ) } | z _ { 0 } ^ { ( b ) } ; \phi ) - \mathrm { K L } ( q _ { \psi } ( z | x ^ { ( b ) } ) | | p ( z ) )$ . With ξ(b)0 = {z(b)0 , v(b)0 , d(b)0 } Define the energy function $U _ { x ^ { ( b ) } } ( z ) = - \log p ( x ^ { ( b ) } | z ; \theta ) - \log p ( z )$ $\mathcal { L } _ { \mathrm { S a m p l e r } }  0$ $\lambda  \sqrt { \mathrm { V a r } ( q _ { \psi } ( z _ { 0 } ^ { ( b ) } | x ^ { ( b ) } ) }$ for $j = 0$ to $J - 1$ do ξ (j −b) ← Rξ(b)j LSampler ← LSampler + \`λ(ξ(b)j , FLθξ(b)j , A(FLθξ(b)j |ξ(b)j )) Set $\xi _ { j + 1 } ^ { ( b ) }$ to $\mathbf { F L } _ { \theta } \boldsymbol { \xi } _ { j } ^ { ( b ) }$ with probability $A ( \mathbf { F L } _ { \theta } \xi _ { j } ^ { ( b ) } | \xi _ { j } ^ { ( b ) } )$ . $\begin{array} { r } { \begin{array} { l l } { \frac { \operatorname { c a s s a } ^ { \ast } \operatorname { s o r } } { \mathcal { L } _ { \mathrm { D e c o d e r } } }  \mathcal { L } _ { \mathrm { D e c o d e r } } + \log p ( x ^ { ( b ) } | z _ { J } ^ { ( s ) } ; \phi ) } & { \qquad \mathrm { ~ s ~ W i t h ~ } \xi _ { J } ^ { ( b ) } = \{ z _ { J } ^ { ( b ) } , v _ { J } ^ { ( b ) } , d _ { J } ^ { ( b ) } \} } \end{array} } \end{array}$ end for $\begin{array} { l } { \phi  \phi + \alpha _ { t } \nabla _ { \phi } \mathcal { L } _ { \mathrm { D e c o d e r } } } \\ { \psi  \psi + \alpha _ { t } \nabla _ { \psi } \mathcal { L } _ { \mathrm { E L B O } } } \\ { \theta  \theta + \alpha _ { t } \nabla _ { \theta } \mathcal { L } _ { \mathrm { S a m p l e r } } } \end{array}$   
+end for   
+$\begin{array} { r l } { 3 } & { 0 } & { 1 \leq 9 \leq 9 \leq 2 \leq 9 \leq 5 } \\ { 2 } & { 4 \times 1 \leq 2 \leq 3 \leq 6 } \\ { 6 } & { 5 \leq 2 \leq 3 \leq 5 } \\ { 3 } & { 6 \leq 8 \leq 7 \leq 3 \leq 4 } \\ { 4 \leq 9 \leq 4 \leq 9 \leq 4 } \\ { 7 \geq 5 \leq 5 \leq 5 \leq 2 \leq 4 \leq 6 } \\ { 0 \leq 6 \leq 1 \leq 2 \leq 2 \leq 4 \leq 6 } \\ { 3 \geq 6 \leq 8 \leq 5 \leq 4 } \end{array}$ 644又9 7 1 9 9 3 / 2 3 S 6 a a 8 7 2 4 一 6 8 9 9 4 D 4 B 7 5 3 6 9 7 7 9 2 4 6 7 0 8 7 ？6 4S q 1 1 23 3 7 9 1 972 076997 090q499 65『6630295147309 h0？b414593&84076 (a) L2HMC (b) HMC (c) VAE
+
+networks $\{ \cdot \} _ { x }$ and $\{ \cdot \} _ { v }$ . The architecture then consists of 2 hidden layers of 200 units and ReLU non-linearities. For $\lambda$ (scale parameter of the loss), we use the standard deviation of the approximate posterior.
+
+AIS Evaluation For each data point, we run 20 Markov Chains in parallel, 10, 000 annealing steps with 10 leapfrogs per step and choose the step size for an acceptance rate of 0.65.
+
+# D.3 MNIST SAMPLES
+
+We show in Figure 5 samples from the three evaluated models: VAE (Kingma & Welling, 2013), HMC-DGLM (Hoffman, 2017) and L2HMC-DGLM.

parse/train/BkbY4psgg/BkbY4psgg.md

@@ -0,0 +1,623 @@
+# MAKING NEURAL PROGRAMMING ARCHITECTURES GENERALIZE VIA RECURSION
+
+Jonathon Cai, Richard Shin, Dawn Song   
+Department of Computer Science   
+University of California, Berkeley   
+Berkeley, CA 94720, USA   
+{jonathon,ricshin,dawnsong}@cs.berkeley.edu
+
+# ABSTRACT
+
+Empirically, neural networks that attempt to learn programs from data have exhibited poor generalizability. Moreover, it has traditionally been difficult to reason about the behavior of these models beyond a certain level of input complexity. In order to address these issues, we propose augmenting neural architectures with a key abstraction: recursion. As an application, we implement recursion in the Neural Programmer-Interpreter framework on four tasks: grade-school addition, bubble sort, topological sort, and quicksort. We demonstrate superior generalizability and interpretability with small amounts of training data. Recursion divides the problem into smaller pieces and drastically reduces the domain of each neural network component, making it tractable to prove guarantees about the overall system’s behavior. Our experience suggests that in order for neural architectures to robustly learn program semantics, it is necessary to incorporate a concept like recursion.
+
+# 1 INTRODUCTION
+
+Training neural networks to synthesize robust programs from a small number of examples is a challenging task. The space of possible programs is extremely large, and composing a program that performs robustly on the infinite space of possible inputs is difficult—in part because it is impractical to obtain enough training examples to easily disambiguate amongst all possible programs. Nevertheless, we would like the model to quickly learn to represent the right semantics of the underlying program from a small number of training examples, not an exhaustive number of them.
+
+Thus far, to evaluate the efficacy of neural models on programming tasks, the only metric that has been used is generalization of expected behavior to inputs of greater complexity (Vinyals et al. (2015), Kaiser & Sutskever (2015), Reed & de Freitas (2016), Graves et al. (2016), Zaremba et al. (2016)). For example, for the addition task, the model is trained on short inputs and then tested on its ability to sum inputs with much longer numbers of digits. Empirically, existing models suffer from a common limitation—generalization becomes poor beyond a threshold level of complexity. Errors arise due to undesirable and uninterpretable dependencies and associations the architecture learns to store in some high-dimensional hidden state. This makes it difficult to reason about what the model will do when given complex inputs.
+
+One common strategy to improve generalization is to use curriculum learning, where the model is trained on inputs of gradually increasing complexity. However, models that make use of this strategy eventually fail after a certain level of complexity (e.g. the single-digit multiplication task in Zaremba et al. (2016), the bubble sort task in Reed & de Freitas (2016), and the graph tasks in Graves et al. (2016)). In this version of curriculum learning, even though the inputs are gradually becoming more complex, the semantics of the program is succinct and does not change. Although the model is exposed to more and more data, it might learn spurious and overly complex representations of the program, as suggested in Zaremba et al. (2016). That is to say, the network does not learn the true program semantics.
+
+In this paper, we propose to resolve these issues by explicitly incorporating recursion into neural architectures. Recursion is an important concept in programming languages and a critical tool to reduce the complexity of programs. We find that recursion makes it easier for the network to learn the right program and generalize to unknown situations. Recursion enables provable guarantees on neural programs’ behavior without needing to exhaustively enumerate all possible inputs to the programs. This paper is the first (to our knowledge) to investigate the important problem of provable generalization properties of neural programs. As an application, we incorporate recursion into the Neural Programmer-Interpreter architecture and consider four sample tasks: grade-school addition, bubble sort, topological sort, and quicksort. Empirically, we observe that the learned recursive programs solve all valid inputs with $100 \%$ accuracy after training on a very small number of examples, out-performing previous generalization results. Given verification sets that cover all the base cases and reduction rules, we can provide proofs that these learned programs generalize perfectly. This is the first time one can provide provable guarantees of perfect generalization for neural programs.
+
+# 2 THE PROBLEM AND OUR APPROACH
+
+# 2.1 THE PROBLEM OF GENERALIZATION
+
+When constructing a neural network for the purpose of learning a program, there are two orthogonal aspects to consider. The first is the actual model architecture. Numerous models have been proposed for learning programs; to name a few, this includes the Differentiable Neural Computer (Graves et al., 2016), Neural Turing Machine (Graves et al., 2014), Neural GPU (Kaiser & Sutskever, 2015), Neural Programmer (Neelakantan et al., 2015), Pointer Network (Vinyals et al., 2015), Hierarchical Attentive Memory (Andrychowicz & Kurach, 2016), and Neural Random Access Machine (Kurach et al., 2016). The architecture usually possesses some form of memory, which could be internal (such as the hidden state of a recurrent neural network) or external (such as a discrete “scratch pad” or a memory block with differentiable access). The second is the training procedure, which consists of the form of the training data and the optimization process. Almost all architectures train on program input/output pairs. The only model, to our knowledge, that does not train on input-output pairs is the Neural Programmer-Interpreter (Reed & de Freitas, 2016), which trains on synthetic execution traces.
+
+To evaluate a neural network that learns a neural program to accomplish a certain task, one common evaluation metric is how well the learned model $M$ generalizes. More specifically, when $M$ is trained on simpler inputs, such as inputs of a small length, the generalization metric evaluates how well $M$ will do on more complex inputs, such as inputs of much longer length. $M$ is considered to have perfect generalization if $M$ can give the right answer for any input, such as inputs of arbitrary length.
+
+As mentioned in Section 1, all approaches to neural programming today fare poorly on this generalization issue. We hypothesize that the reason for this is that the neural network learns to spuriously depend on specific characteristics of the training examples that are irrelevant to the true program semantics, such as length of the training inputs, and thus fails to generalize to more complex inputs.
+
+In addition, none of the current approaches to neural programming provide a method or even aim to enable provable guarantees about generalization. The memory updates of these neural programs are so complex and interdependent that it is difficult to reason about the behaviors of the learned neural program under previously unseen situations (such as problems with longer inputs). This is highly undesirable, since being able to provide the correct answer in all possible settings is one of the most important aspects of any learned neural program.
+
+# 2.2 OUR APPROACH USING RECURSION
+
+In this paper, we propose that the key abstraction of recursion is necessary for neural programs to generalize. The general notion of recursion has been an important concept in many domains, including mathematics and computer science. In computer science, recursion (as opposed to iteration) involves solving a larger problem by combining solutions to smaller instances of the same problem. Formally, a function exhibits recursive behavior when it possesses two properties: (1) Base cases— terminating scenarios that do not use recursion to produce answers; (2) A set of rules that reduces all other problems toward the base cases. Some functional programming languages go so far as not to define any looping constructs but rely solely on recursion to enable repeated execution of the same code.
+
+In this paper, we propose that recursion is an important concept for neural programs as well. In fact, we argue that recursion is an essential element for neural programs to generalize, and makes it tractable to prove the generalization of neural programs. Recursion can be implemented differently for different neural programming models. Here as a concrete and general example, we consider a general Neural Programming Architecture (NPA), similar to Neural Programmer-Interpreter (NPI) in Reed & de Freitas (2016). In this architecture, we consider a core controller, e.g., an LSTM in NPI’s case, but possibly other networks in different cases. There is a (changing) list of neural programs used to accomplish a given task. The core controller acts as a dispatcher for the programs. At each time step, the core controller can decide to select one of the programs to call with certain arguments. When the program is called, the current context including the caller’s memory state is stored on a stack; when the program returns, the stored context is popped off the stack to resume execution in the previous caller’s context.
+
+In this general Neural Programming Architecture, we show it is easy to support recursion. In particular, recursion can be implemented as a program calling itself. Because the context of the caller is stored on a stack when it calls another program and the callee starts in a fresh context, this enables recursion simply by allowing a program to call itself. In practice, we can additionally use tail recursion optimization to avoid problems with the call stack growing too deep. Thus, any general Neural Programming Architecture supporting such a call structure can be made to support recursion. In particular, this condition is satisfied by NPI, and thus the NPI model naturally supports recursion (even though the authors of NPI did not consider this aspect explicitly).
+
+By nature, recursion reduces the complexity of a problem to simpler instances. Thus, recursion helps decompose a problem and makes it easier to reason about a program’s behavior for previously unseen situations such as longer inputs. In particular, given that a recursion is defined by two properties as mentioned before, the base cases and the set of reduction rules, we can prove a recursive neural program generalizes perfectly if we can prove that (1) it performs correctly on the base cases; (2) it learns the reduction rules correctly. For many problems, the base cases and reduction rules usually consist of a finite (often small) number of cases. For problems where the base cases may be extremely large or infinite, such as certain forms of motor control, recursion can still help reduce the problem of generalization to these two aspects and make the generalization problem significantly simpler to handle and reason about.
+
+As a concrete instantiation, we show in this paper that we can enable recursive neural programs in the NPI model, and thus enable perfectly generalizable neural programs for tasks such as sorting where the original, non-recursive NPI program fails. As aforementioned, the NPI model naturally supports recursion. However, the authors of NPI did not consider explicitly the notion of recursion and as a consequence, did not learn recursive programs. We show that by modifying the training procedure, we enable the NPI model to learn recursive neural programs. As a consequence, our learned neural programs empirically achieve perfect generalization from a very small number of training examples. Furthermore, given a verification input set that covers all base cases and reduction rules, we can formally prove that the learned neural programs achieve perfect generalization after verifying its behavior on the verification input set. This is the first time one can provide provable guarantees of perfect generalization for neural programs.
+
+We would also like to point out that in this paper, we provide as an example one way to train a recursive neural program, by providing a certain training execution trace to the NPI model. However, our concept of recursion for neural programs is general. In fact, it is one of our future directions to explore new ways to train a recursive neural program without providing explicit training execution traces or with only partial or non-recursive traces.
+
+# 3 APPLICATION TO LEARNING RECURSIVE NEURAL PROGRAMS WITH NPI
+
+# 3.1 BACKGROUND: NPI ARCHITECTURE
+
+As discussed in Section 2, the Neural Programmer-Interpreter (NPI) is an instance of a Neural Programmer Architecture and hence it naturally supports recursion. In this section, we give a brief review of the NPI architecture from Reed & de Freitas (2016) as background.
+
+We describe the details of the NPI model relevant to our contributions. We adapt machinery from the original paper slightly to fit our needs. The NPI model has three learnable components: a task-agnostic core, a program-key embedding, and domain-specific encoders that allow the NPI to operate in diverse environments.
+
+The NPI accesses an external environment, $Q$ , which varies according to the task. The core module of the NPI is an LSTM controller that takes as input a slice of the current external environment, via a set of pointers, and a program and arguments to execute. NPI then outputs the return probability and next program and arguments to execute. Formally, the NPI is represented by the following set of equations:
+
+$$
+\begin{array} { c } { s _ { t } = f _ { e n c } ( e _ { t } , a _ { t } ) } \\ { h _ { t } = f _ { l s t m } ( s _ { t } , p _ { t } , h _ { t - 1 } ) } \\ { r _ { t } = f _ { e n d } ( h _ { t } ) , p _ { t + 1 } = f _ { p r o g } ( h _ { t } ) , a _ { t + 1 } = f _ { a r g } ( h _ { t } ) } \end{array}
+$$
+
+$t$ is a subscript denoting the time-step; $f _ { e n c }$ is a domain-specific encoder (to be described later) that takes in the environment slice $e _ { t }$ and arguments $a _ { t }$ ; $f _ { l s t m }$ represents the core module, which takes in the state $s _ { t }$ generated by $f _ { e n c }$ , a program embedding $p _ { t } \in \mathbb { R } ^ { P }$ , and hidden LSTM state $h _ { t }$ ; $f _ { e n d }$ decodes the return probability $r _ { t }$ ; $f _ { p r o g }$ decodes a program key embedding $p _ { t + 1 }$ ;1 and $f _ { a r g }$ decodes arguments $a _ { t + 1 }$ . The outputs $r _ { t } , p _ { t + 1 } , a _ { t + 1 }$ are used to determine the next action, as described in Algorithm 1. If the program is primitive, the next environmental state $e _ { t + 1 }$ will be affected by $p _ { t }$ and $a _ { t }$ , i.e. $e _ { t + 1 } \sim f _ { e n v } ( e _ { t } , p _ { t } , a _ { t } )$ . As with the original NPI architecture, the experiments for this paper always used a 3-tuple of integers $a _ { t } = ( a _ { t } ( 1 ) , \hat { a } _ { t } ( 2 ) , a _ { t } ( 3 ) )$ .
+
+Algorithm 1 Neural programming inference   
+
+<table><tr><td>1:</td><td>Inputs: Environment observation e, program p,arguments a, stop threshold α</td></tr><tr><td>2:</td><td>function RUN(e,p, a)</td></tr><tr><td>3:</td><td>h↑0,r←0</td></tr><tr><td>4:</td><td>whiler&lt;αdo</td></tr><tr><td>5:</td><td>s ←fenc(e,a),h ←fistm(s,p,h)</td></tr><tr><td>6:</td><td>r ←fend(h),p2 ← fprog(h),a2 ← farg(h)</td></tr><tr><td>7:</td><td>if p is a primitive function then</td></tr><tr><td>8:</td><td>e ← fenv(e,p,a).</td></tr><tr><td>9:</td><td>else</td></tr><tr><td>10:</td><td>function RUN(e,P2, a2)</td></tr></table>
+
+A description of the inference procedure is given in Algorithm 1. Each step during an execution of the program does one of three things: (1) another subprogram along with associated arguments is called, as in Line 10, (2) the program writes to the environment if it is primitive, as in Line 8, or (3) the loop is terminated if the return probability exceeds a threshold $\alpha$ , after which the stack frame is popped and control is returned to the caller. In all experiments, $\alpha$ is set to 0.5. Each time a subprogram is called, the stack depth increases.
+
+The training data for the Neural Programmer-Interpreter consists of full execution traces for the program of interest. A single element of an execution trace consists of a step input-step output pair, which can be synthesized from Algorithm 1: this corresponds to, for a given time-step, the step input tuple $( e , p , a )$ and step output tuple $( r , p _ { 2 } , a _ { 2 } )$ . An example of part of an addition task trace, written in shorthand, is given in Figure 1. For example, a step input-step output pair in Lines 2 and 3 of the left-hand side of Figure 1 is (ADD1, WRITE OUT 1). In this pair, the step input runs a subprogram ADD1 that has no arguments, and the step output contains a program WRITE that has arguments of OUT and 1. The environment and return probability are omitted for readability. Indentation indicates the stack is one level deeper than before.
+
+It is important to emphasize that at inference time in the NPI, the hidden state of the LSTM controller is reset (to zero) at each subprogram call, as in Line 3 of Algorithm 1 $h  \mathbf { 0 }$ ). This functionality is critical for implementing recursion, since it permits us to restrict our attention to the currently relevant recursive call, ignoring irrelevant details about other contexts.
+
+![](images/400738f1bb6ec680e00398081df8b91a36e097048042ec5fdd599e1e2221cb5f.jpg)  
+Figure 1: Addition Task. The non-recursive trace loops on cycles of ADD1 and LSHIFT, whereas in the recursive version, the ADD function calls itself (bolded).
+
+# 3.2 RECURSIVE FORMULATIONS FOR NPI PROGRAMS
+
+We emphasize the overall goal of this work is to enable the learning of a recursive program. The learned recursive program is different from neural programs learned in all previous work in an important aspect: previous approaches do not explicitly incorporate this abstraction, and hence generalize poorly, whereas our learned neural programs incorporate recursion and achieve perfect generalization.
+
+Since NPI naturally supports the notion of recursion, a key question is how to enable NPI to learn recursive programs. We found that changing the NPI training traces is a simple way to enable this. In particular, we construct new training traces which explicitly contain recursive elements and show that with this type of trace, NPI easily learns recursive programs. In future work, we would like to decrease supervision and construct models that are capable of coming up with recursive abstractions themselves.
+
+In what follows, we describe the way in which we constructed NPI training traces so as to make them contain recursive elements and thus enable NPI to learn recursive programs. We describe the recursive re-formulation of traces for two tasks from the original NPI paper—grade-school addition and bubble sort. For these programs, we re-use the appropriate program sets (the associated subprograms), and we refer the reader to the appendix of Reed & de Freitas (2016) for further details on the subprograms used in addition and bubble sort. Finally, we implement recursive traces for our own topological sort and quicksort tasks.
+
+Grade School Addition. For grade-school addition, the domain-specific encoder is
+
+$$
+\begin{array} { r } { f _ { e n c } ( Q , i _ { 1 } , i _ { 2 } , i _ { 3 } , i _ { 4 } , a _ { t } ) = M L P ( [ Q ( 1 , i _ { 1 } ) , Q ( 2 , i _ { 2 } ) , Q ( 3 , i _ { 3 } ) , Q ( 4 , i _ { 4 } ) , a _ { t } ( 1 ) , a _ { t } ( 2 ) , a _ { t } ( 3 ) ] ) , } \end{array}
+$$
+
+where the environment $Q \in \mathbb { R } ^ { 4 \times N \times K }$ is a scratch-pad that contains four rows (the first input number, the second input number, the carry bits, and the output) and $N$ columns. $K$ is set to 11, to represent the range of 10 possible digits, along with a token representing the end of input.2 At any given time, the NPI has access to values pointed to by four pointers in each of the four rows, represented by $Q ( 1 , i _ { 1 } ) , Q ( 2 , i _ { 2 } ) , Q ( 3 , i _ { 3 } )$ , and $Q ( 4 , i _ { 4 } )$ .
+
+The non-recursive trace loops on cycles of ADD1 and LSHIFT. ADD1 is a subprogram that adds the current column (writing the appropriate digit to the output row and carrying a bit to the next column if needed). LSHIFT moves the four pointers to the left, to move to the next column. The program terminates when seeing no numbers in the current column.
+
+Figure 1 shows examples of non-recursive and recursive addition traces. We make the trace recursive by adding a tail recursive call into the trace for the ADD program after calling ADD1 and LSHIFT,
+
+# Full Recursive
+
+![](images/54ac005719045e00f6d938466b5b91cbc2d9b186869b92dd8c3b93eb2423cdb1.jpg)  
+Figure 2: Bubble Sort Task. The non-recursive trace loops on cycles of BUBBLE and RESET. The difference between the partial recursive and full recursive versions is in the indentation of Lines 10-15 and 20-22 (bolded), since in the full recursive version, BSTEP and LSHIFT are made tail recursive; the final calls to BSTEP and LSHIFT return immediately as they occur after the pointer reaches the end of the array. Also note that COMPSWAP conditionally swaps numbers under the bubble pointers.
+
+as in Line 13 of the right-hand side of Figure 1. Via the recursive call, we effectively forget that the column just added exists, since the recursive call to ADD starts with a new hidden state for the LSTM controller. Consequently, there is no concept of length relevant to the problem, which has traditionally been an important focus of length-based curriculum learning.
+
+Bubble Sort. For bubble sort, the domain-specific encoder is
+
+$$
+f _ { e n c } ( Q , i _ { 1 } , i _ { 2 } , i _ { 3 } , a _ { t } ) = M L P ( [ Q ( 1 , i _ { 1 } ) , Q ( 1 , i _ { 2 } ) , i _ { 3 } = l e n g t h , a _ { t } ( 1 ) , a _ { t } ( 2 ) , a _ { t } ( 3 ) ] ) ,
+$$
+
+where the environment $Q \in \mathbb { R } ^ { 1 \times N \times K }$ is a scratch-pad that contains 1 row, to represent the state of the array as sorting proceeds in-place, and $N$ columns. $K$ is set to 11, to denote the range of possible numbers (0 through 9), along with the start/end token (represented with the same encoding) which is observed when a pointer reaches beyond the bounds of the input. At any given time, the NPI has access to the values referred to by two pointers, represented by $Q ( 1 , i _ { 1 } )$ and $Q ( 1 , i _ { 2 } )$ ,. The pointers at index $i _ { 1 }$ and $i _ { 2 }$ are used to compare the pair of numbers considered during the bubble sweep, swapping them if the number at $i _ { 1 }$ is greater than that in $i _ { 2 }$ . These pointers are referred to as bubble pointers. The pointer at index $i _ { 3 }$ represents a counter internal to the environment that is incremented once after each pass of the algorithm (one cycle of BUBBLE and RESET); when incremented a number of times equal to the length of the array, the flag $i _ { 3 } = =$ length becomes true and terminates the entire algorithm .
+
+The non-recursive trace loops on cycles of BUBBLE and RESET, which logically represents one bubble sweep through the array and reset of the two bubble pointers to the very beginning of the array, respectively. In this version, there is a dependence on length: BSTEP and LSHIFT are called a number of times equivalent to one less than the length of the input array, in BUBBLE and RESET respectively.
+
+Inside BUBBLE and RESET, there are two operations that can be made recursive. BSTEP, used in BUBBLE, compares pairs of numbers, continuously moving the bubble pointers once to the right each time until reaching the end of the array. LSHIFT, used in RESET, shifts the pointers left until reaching the start token.
+
+We experiment with two levels of recursion—partial and full. Partial recursion only adds a tail recursive call to BUBBLESORT after BUBBLE and RESET, similar to the tail recursive call described previously for addition. The partial recursion is not enough for perfect generalization, as will be presented later in Section 4. Full recursion, in addition to making the aforementioned tail recursive call, adds two additional recursive calls; BSTEP and LSHIFT are made tail recursive. Figure 2 shows examples of traces for the different versions of bubble sort. Training on the full recursive trace leads to perfect generalization, as shown in Section 4. We performed experiments on the partially recursive version in order to examine what happens when only one recursive call is implemented, when in reality three are required for perfect generalization.
+
+# Algorithm 2 Depth First Search Topological Sort
+
+1: Color all vertices white.   
+2: Initialize an empty stack $S$ and a directed acyclic graph $D A G$ to traverse. 3: Begin traversing from Vertex 1 in the DAG. 4: function TOPOSORT $( D A G )$ 5: while there is still a white vertex $u$ : do 6: color[u] = grey 7: $v _ { a c t i v e } = u$ 8: do   
+9: if $v _ { a c t i v e }$ has a white child $v$ then   
+10: $\operatorname { c o l o r } [ v ] = \operatorname { g r e y }$   
+11: push $v _ { a c t i v e }$ onto $S$   
+12: $v _ { a c t i v e } = v$   
+13: else   
+14: $\mathrm { c o l o r } [ v _ { a c t i v e } ] = \mathrm { b l a c k }$   
+15: Write $v _ { a c t i v e }$ to result   
+16: if $S$ is empty then pass   
+17: else pop the top vertex off $S$ and set it to $v _ { a c t i v e }$   
+18: while $S$ is not empty
+
+Topological Sort. We choose to implement a topological sort task for graphs. A topological sort is a linear ordering of vertices such that for every directed edge $( u , v )$ from $u$ to $v , u$ comes before $v$ in the ordering. This is possible if and only if the graph has no directed cycles; that is to say, it must be a directed acyclic graph (DAG). In our experiments, we only present DAG’s as inputs and represent the vertices as values ranging from $1 , \ldots , n$ , where the DAG contains $n$ vertices.
+
+Directed acyclic graphs are structurally more diverse than inputs in the two tasks of grade-school addition and bubble sort. The degree for any vertex in the DAG is variable. Also the DAG can have potentially more than one connected component, meaning it is necessary to transition between these components appropriately.
+
+Algorithm 2 shows the topological sort task of interest. This algorithm is a variant of depth first search. We created a program set that reflects the semantics of Algorithm 2. For brevity, we refer the reader to the appendix for further details on the program set and non-recursive and recursive trace-generating functions used for topological sort.
+
+For topological sort, the domain-specific encoder is
+
+$$
+\begin{array} { r l } & { \ f _ { e n c } ( D A G , Q _ { c o l o r } , p _ { s t a c k } , p _ { s t a r t } , v _ { a c t i v e } , c h i l d L i s t , a _ { t } ) } \\ & { = M L P ( [ Q _ { c o l o r } ( p _ { s t a r t } ) , Q _ { c o l o r } ( D A G [ v _ { a c t i v e } ] [ c h i l d L i s t [ v _ { a c t i v e } ] ] ) , p _ { s t a c k } = = 1 , a _ { t } ( 1 ) , a _ { t } ( 2 ) , a _ { t } ( 3 ) , a _ { t } ) } \end{array}
+$$
+
+where $Q _ { c o l o r } \in \mathbb { R } ^ { U \times 4 }$ is a scratch-pad that contains $U$ rows, each containing one of four colors (white, gray, black, invalid) with one-hot encoding. $U$ varies with the number of vertices in the graph. We further have $Q _ { r e s u l t } \in \mathbb { N } ^ { U }$ , a scratch-pad which contains the sorted list of vertices at the end of execution, and $Q _ { s t a c k } \in \mathbb { N } ^ { U }$ , which serves the role of the stack $S$ in Algorithm 2. The contents of $Q _ { r e s u l t }$ and $Q _ { s t a c k }$ are not exposed directly through the domain-specific encoder; rather, we define primitive functions which manipulate these scratch-pads.
+
+The DAG is represented as an adjacency list where $D A G [ i ] [ j ]$ refers to the $j$ -th child of vertex $i$ . There are 3 pointers $( p _ { r e s u l t } , p _ { s t a c k } , p _ { s t a r t } )$ , $p _ { r e s u l t }$ points to the next empty location in $Q _ { r e s u l t }$ $p _ { s t a c k }$ points to the top of the stack in $Q _ { s t a c k }$ , and $p _ { s t a r t }$ points to the candidate starting node for a connected component. There are 2 variables ( $\boldsymbol { v } _ { a c t i v e }$ and $v _ { s a v e . }$ ); $v _ { a c t i v e }$ holds the active vertex (as in Algorithm 2) and $v _ { s a v e }$ holds the value of $v _ { a c t i v e }$ before executing Line 12 of Algorithm 2. $c h i l d L i s t \in \mathbb { N } ^ { U }$ is a vector of pointers, where childList[i] points to the next child under consideration for vertex $i$ .
+
+The three environment observations aid with control flow in Algorithm 2. $Q _ { c o l o r } ( p _ { s t a r t } )$ contains the color of the current start vertex, used in the evaluation of the condition in the WHILE loop in Line 5 of Algorithm 2. $Q _ { c o l o r } ( D A G [ v _ { a c t i v e } ] [ c h i l d L i s t [ v _ { a c t i v e } ] ] )$ refers to the color of the next child of $v _ { a c t i v e }$ , used in the evaluation of the condition in the IF branch in Line 9 of Algorithm 2. Finally, the boolean $p _ { s t a c k } = = 1$ is used to check whether the stack is empty in Line 18 of Algorithm 2.
+
+An alternative way of representing the environment slice is to expose the values of the absolute vertices to the model; however, this makes it difficult to scale the model to larger graphs, since large vertex values are not seen during training time.
+
+We refer the reader to the appendix for the non-recursive trace generating functions. In the non-recursive trace, there are four functions that can be made recursive—TOPOSORT, CHECK CHILD, EXPLORE, and NEXT START, and we add a tail recursive call to each of these functions in order to make the recursive trace. In particular, in the EXPLORE function, adding a tail recursive call resets and stores the hidden states associated with vertices in a stack-like fashion. This makes it so that we only need to consider the vertices in the subgraph that are currently relevant for computing the sort, allowing simpler reasoning about behavior for large graphs. The sequence of primitive operations (MOVE and WRITE operations) for the non-recursive and recursive versions are exactly the same.
+
+Quicksort. We implement a quicksort task, in order to demonstrate that recursion helps with learning divide-and-conquer algorithms. We use the Lomuto partition scheme; the logic for the recursive trace is shown in Algorithm 3. For brevity, we refer the reader to the appendix for information about the program set and non-recursive and recursive trace-generating functions for quicksort. The logic for the non-recursive trace is shown in Algorithm 4 in the appendix.
+
+# Algorithm 3 Recursive Quicksort
+
+1: Initialize an array $A$ to sort.   
+2: Initialize $l o$ and $h i$ to be 1 and $n$ , where $n$ is the length of $A$ .   
+3:   
+4: function QUICKSORT $( A , l o , h i )$   
+5: if $l o < h i$ : then   
+6: $\mathsf { p } = \mathsf { P A R T I T I O N } ( A , l o , h i )$   
+7: $\mathrm { Q U I C K S O R T } ( A , l o , p - 1 )$   
+8: $\operatorname { Q U I C K S O R T } ( A , p + 1 , h i )$   
+9:   
+10: function PARTITION $( A , l o , h i )$   
+11: $p i v o t = l o$   
+12: for $j \in [ l o , h i - 1 ] : \mathbf { d o }$   
+13: if $A [ j ] \leq A [ h i ]$ then   
+14: swap A[pivot] with $A [ j ]$   
+15: pivot = pivot + 1   
+16: swap A[pivot] with A[hi]   
+17: return pivot
+
+For quicksort, the domain-specific encoder is
+
+$$
+\begin{array} { r l } & { f _ { e n c } ( Q _ { a r r a y } , Q _ { s t a c k L o } , Q _ { s t a c k H i } , p _ { l o } , p _ { h i } , p _ { s t a c k L o } , p _ { s t a c k H i } , p _ { p i v o t } , p _ { j } , a _ { t } ) = } \\ & { \qquad M L P ( [ Q _ { a r r a y } ( p _ { j } ) \leq Q _ { a r r a y } ( p _ { h i } ) , p _ { j } = = p _ { h i } , } \\ & { \qquad Q _ { s t a c k L o } ( p _ { s t a c k L o } - 1 ) < Q _ { s t a c k H i } ( p _ { s t a c k H i } - 1 ) , p _ { s t a c k L o } = = } \\ & { \qquad \quad M L P ( [ Q _ { a r r a y } ( p _ { j } ) \leq \mathfrak { a } _ { t } ( 2 ) , a _ { t } ( 3 ) ] ) , } \end{array}
+$$
+
+where $Q _ { a r r a y } \in \mathbb { R } ^ { U \times 1 1 }$ is a scratch-pad that contains $U$ rows, each containing one of 11 values (one of the numbers 0 through 9 or an invalid state). Our implementation uses two stacks $Q _ { s t a c k L o }$ and
+
+$Q _ { s t a c k H i }$ , each in $\mathbb { R } ^ { U }$ , that store the arguments to the recursive QUICKSORT calls in Algorithm 3; before each recursive call, the appropriate arguments are popped off the stack and written to $p _ { l o }$ and $p _ { h i }$ .
+
+There are 6 pointers $( p _ { l o } , p _ { h i } , p _ { s t a c k L o } , p _ { s t a c k H i } , p _ { p i v o t } , p _ { j } )$ . $p _ { l o }$ and $p _ { h i }$ point to the lo and hi indices of the array, as in Algorithm 3. $p _ { s t a c k L o }$ and $p _ { s t a c k H i }$ point to the top (empty) positions in $Q _ { s t a c k L o }$ and $Q _ { s t a c k H i }$ . $p _ { p i v o t }$ and $p _ { j }$ point to the pivot and $j$ indices of the array, used in the PARTITION function in Algorithm 3. The 4 environment observations aid with control flow; $Q _ { s t a c k L o } ( p _ { s t a c k L o } - 1 ) < Q _ { s t a c k H i } ( p _ { s t a c k H i } - 1 )$ implements the $l o < h i$ comparison in Line 5 of Algorithm 3, $p _ { s t a c k L o } = = 1$ checks if the stacks are empty in Line 18 of Algorithm 4, and the other observations (all involving $p _ { p i v o t }$ or $p _ { j }$ ) deal with logic in the PARTITION function.
+
+Note that the recursion for quicksort is not purely tail recursive and therefore represents a more complex kind of recursion that is harder to learn than in the previous tasks. Also, compared to the bubble pointers in bubble sort, the pointers that perform the comparison for quicksort (the COMPSWAP function) are usually not adjacent to each other, making quicksort less local than bubble sort. In order to compensate for this, $p _ { p i v o t }$ and $p _ { j }$ require special functions (MOVE PIVOT LO and MOVE J LO) to properly set them to $l o$ in Lines 11 and 12 of the PARTITION function in Algorithm 3.
+
+# 3.3 PROVABLY PERFECT GENERALIZATION
+
+We show that if we incorporate recursion, the learned NPI programs can achieve provably perfect generalization for different tasks. Provably perfect generalization implies the model will behave correctly, given any valid input. In order to claim a proof, we must verify the model produces correct behavior over all base cases and reductions, as described in Section 2.
+
+We propose and describe our verification procedure. This procedure verifies that all base cases and reductions are handled properly by the model via explicit tests. Note that recursion helps make this process tractable, because we only need to test a finite number of inputs to show that the model will work correctly on inputs of unbounded complexity. This verification phase only needs to be performed once after training.
+
+Formally, verification consists of proving the following theorem:
+
+$$
+\forall i \in V , M ( i ) \downdownarrows P ( i )
+$$
+
+where $i$ denotes a sequence of step inputs (within one function call), $V$ denotes the set of valid sequences of step inputs, $M$ denotes the neural network model, $P$ denotes the correct program, and $P ( i )$ denotes the next step output from the correct program. The arrow in the theorem refers to evaluation, as in big-step semantics. The theorem states that for the same sequence of step inputs, the model produces the exact same step output as the target program it aims to learn. $M$ , as described in Algorithm 1, processes the sequence of step inputs by using an LSTM.
+
+Recursion drastically reduces the number of configurations we need to consider during the verification phase and makes the proof tractable, because it introduces structure that eliminates infinitely long sequences of step inputs that would otherwise need to be considered. For instance, for recursive addition, consider the family $F$ of addition problems $a _ { n } a _ { n - 1 } \dots a _ { 1 } a _ { 0 } + b _ { n } b _ { n - 1 } \dots b _ { 1 } b _ { 0 }$ where no CARRY operations occur. We prove every member of $F$ is added properly, given that subproblems $S = \{ a _ { n } a _ { n - 1 } + b _ { n } b _ { n - 1 } , a _ { n - 1 } { \bar { a } } _ { n - 2 } + b _ { n - 1 } b _ { n - 2 } , \dots , a _ { 1 } a _ { 0 } + b _ { 1 } b _ { 0 } \}$ are added properly.
+
+Without using a recursive program, such a proof is not possible, because the non-recursive program runs on an arbitrarily long addition problem that creates correspondingly long sequences of step inputs; in the non-recursive formulation of addition, ADD calls ADD1 a number of times that is dependent on the length of the input. The core LSTM module’s hidden state is preserved over all these ADD1 calls, and it is difficult to interpret with certainty what happens over longer timesteps without concretely evaluating the LSTM with an input of that length. In contrast, each call to the recursive ADD always runs for a fixed number of steps, even on arbitrarily long problems in $F$ , so we can test that it performs correctly on a small, fixed number of step input sequences. This guarantees that the step input sequences considered during verification contain all step input sequences which arise during execution of an unseen problem in $F$ , leading to generalization to any problem in $F$ . Hence, if all subproblems in $S$ are added correctly, we have proven that any member of $F$ will be added correctly, thus eliminating an infinite family of inputs that need to be tested.
+
+To perform the verification as described here, it is critical to construct $V$ correctly. If it is too small, then execution of the program on some input might require evaluation of $M ( i )$ on some $i \not \in V$ , and so the behavior of $M ( i )$ might deviate from $P ( i )$ . If it is too large, then the semantics of $P$ might not be well-defined on some elements in $V$ , or the spurious step input sequences may not be reachable from any valid problem input (e.g., an array for quicksort or a DAG for topological sort).
+
+To construct this set, by using the reference implementation of each subprogram, we construct a mapping between two sets of environment observations: the first set consists of all observations that can occur at the beginning of a particular subprogram’s invocation, and the second set contains the observations at the end of that subprogram. We can obtain this mapping by first considering the possible observations that can arise at the beginning of the entry function (ADD, BUBBLESORT, TOPOSORT, and QUICKSORT) for some valid program input, and iteratively applying the observation-to-observation mapping implied by the reference implementation’s step output at that point in the execution. If the step output specifies a primitive function call, we need to reason about how it can affect the environment so as to change the observation in the next step input. For non-primitive subprograms, we can update the observation-to-observation mapping currently associated with the subprogram and then apply that mapping to the current set. By iterating with this procedure, and then running $P$ on the input observation set that we obtain for the entry point function, we can obtain $V$ precisely. To make an analogy to MDPs, this procedure is analogous to how value iteration obtains the correct value for each state starting from any initialization.
+
+An alternative method is to run $P$ on many different program inputs and then observe step input sequences which occur, to create $V$ . However, to be sure that the generated $V$ is complete (covers all the cases needed), we need to check all pairs of observations seen in adjacent step inputs (in particular, those before and after a primitive function call), in a similar way as if we were constructing $V$ from scratch. Given a precise definition of $P$ , it may be possible to automate the generation of $V$ from $P$ in future work.
+
+Note that $V$ should also contain the necessary reductions, which corresponds to making the recursive calls at the correct time, as indicated by $P$ .
+
+After finding $V$ , we construct a set of problem inputs which, when executed on $P$ , create exactly the step input sequences which make up $V$ . We call this set of inputs the verification set, $S _ { V }$ .
+
+Given a verification set, we can then run the model on the verification set to check if the produced traces and results are correct. If yes, then this indicates that the learned neural program achieves provably perfect generalization.
+
+We note that for tasks with very large input domains, such as ones involving MNIST digits or speech samples, the state space of base cases and reduction rules could be prohibitively large, possibly infinite. Consequently, it is infeasible to construct a verification set that covers all cases, and the verification procedure we have described is inadequate. We leave this as future work to devise a verification procedure more appropriate to this setting.
+
+# 4 EXPERIMENTS
+
+As there is no public implementation of NPI, we implemented a version of it in Keras that is as faithful to the paper as possible. Our experiments use a small number of training examples.
+
+Training Setup. The training set for addition contains 200 traces. The maximum problem length in this training set is 3 (e.g., the trace corresponding to the problem $^ { \mathrm { \left. } } 1 0 9 + 1 0 1 ^ { \mathrm { \right. } }$ ).
+
+The training set for bubble sort contains 100 traces, with maximum problem length of 2 (e.g., the trace corresponding to the array [3,2]).
+
+The training set for topological sort contains 6 traces, with one synthesized from a graph of size 5 and the rest synthesized from graphs of size 7.
+
+The training set for quicksort contains 4 traces, synthesized from arrays of length 5.
+
+The same set of problems was used to generate the training traces for all formulations of the task, for non-recursive and recursive versions.
+
+Table 1: Accuracy on Randomly Generated Problems for Bubble Sort   
+
+<table><tr><td>Length of Array</td><td>Non-Recursive</td><td>PartiallyRecursive</td><td>FullRecursive</td></tr><tr><td></td><td></td><td></td><td></td></tr><tr><td>２3</td><td>100%</td><td>100%</td><td>100%</td></tr><tr><td></td><td>6.7%</td><td>23%</td><td>100%</td></tr><tr><td>4</td><td>10%</td><td>10%</td><td>100%</td></tr><tr><td>8</td><td>0% 0%</td><td>0% 0%</td><td>100% 100%</td></tr><tr><td>20</td><td></td><td></td><td>100%</td></tr><tr><td>90</td><td>0%</td><td>0%</td><td></td></tr></table>
+
+We train using the Adam optimizer and use a 2-layer LSTM and task-specific state encoders for the external environments, as described in Reed & de Freitas (2016).
+
+4.1 RESULTS ON GENERALIZATION OF RECURSIVE NEURAL PROGRAMS
+
+We now report on generalization for the varying tasks.
+
+Grade-School Addition. Both the non-recursive and recursive learned programs generalize on all input lengths we tried, up to 5000 digits. This agrees with the generalization of non-recursive addition in Reed & de Freitas (2016), where they reported generalization up to 3000 digits. However, note that there is no provable guarantee that the non-recursive learned program will generalize to all inputs, whereas we show later that the recursive learned program has a provable guarantee of perfect generalization.
+
+In order to demonstrate that recursion can help learn and generalize better, for addition, we trained only on traces for 5 arbitrarily chosen 1-digit addition sum examples. The recursive version can generalize perfectly to long problems constructed from these components (such as the sum $^ { 6 6 } 8 2 2 + 2 3 3 ^ { 3 }$ , where $\because 8 + 2 ^ { , 5 }$ and $\bar { 2 } + 3 \bar { 2 }$ are in the training set), but the non-recursive version fails to sum these long problems properly.
+
+Bubble Sort. Table 1 presents results on randomly generated arrays of varying length for the learned non-recursive, partially recursive, and full recursive programs. For each length, we test each program on 30 randomly generated problems. Observe that partially recursive does slightly better than non-recursive for the setting in which the length of the array is 3, and that the fully recursive version is able to sort every array given to it. The non-recursive and partially recursive versions are unable to sort long arrays, beyond length 8.
+
+Topological Sort. Both the non-recursive and recursive learned programs generalize on all graphs we tried, up to 120 vertices. As before, the non-recursive learned program lacks a provable guarantee of generalization, whereas we show later that the recursive learned program has one.
+
+In order to demonstrate that recursion can help learn and generalize better, we trained a non-recursive and recursive model on just a single execution trace generated from a graph containing 5 nodes3 for the topological sort task. For these models, Table 2 presents results on randomly generated DAGs of varying graph sizes (varying in the number of vertices). For each graph size, we test the learned programs on 30 randomly generated DAGs. The recursive version of topological sort solves all graph instances we tried, from graphs of size 5 through 70. On the other hand, the non-recursive version has low accuracy, beginning from size 5, and fails completely for graphs of size 8 and beyond.
+
+Quicksort. Table 3 presents results on randomly generated arrays of varying length for the learned non-recursive and recursive programs. For each length, we test each program on 30 randomly generated problems. Observe that the non-recursive program’s correctness degrades for length 11 and beyond, while the recursive program can sort any given array.
+
+Table 2: Accuracy on Randomly Generated Problems for Topological Sort   
+
+<table><tr><td>NumberofVertices</td><td>Non-Recursive</td><td>Recursive</td></tr><tr><td></td><td></td><td></td></tr><tr><td>5</td><td>6.7%</td><td>100%</td></tr><tr><td>6</td><td>6.7%</td><td>100%</td></tr><tr><td>7</td><td>3.3%</td><td>100%</td></tr><tr><td>8</td><td>0%</td><td>100%</td></tr><tr><td>70</td><td>0%</td><td>100%</td></tr></table>
+
+Table 3: Accuracy on Randomly Generated Problems for Quicksort   
+
+<table><tr><td>LengthofArray</td><td>Non-Recursive</td><td>Recursive</td></tr><tr><td>3</td><td>100%</td><td>100%</td></tr><tr><td>5</td><td>100%</td><td>100%</td></tr><tr><td>7</td><td>100%</td><td>100%</td></tr><tr><td>11</td><td>73.3%</td><td>100%</td></tr><tr><td>15</td><td>60%</td><td>100%</td></tr><tr><td>20</td><td>30%</td><td></td></tr><tr><td>22</td><td>20%</td><td>100%</td></tr><tr><td>25</td><td>3.33%</td><td>100%</td></tr><tr><td>30</td><td>3.33%</td><td>100%</td></tr><tr><td></td><td></td><td>100%</td></tr><tr><td>70</td><td>0%</td><td>100%</td></tr></table>
+
+As mentioned in Section 2.1, we hypothesize the non-recursive programs do not generalize well because they have learned spurious dependencies specific to the training set, such as length of the input problems. On the other hand, the recursive programs have learned the true program semantics.
+
+# 4.2 VERIFICATION OF PROVABLY PERFECT GENERALIZATION
+
+We describe how models trained with recursive traces can be proven to generalize, by using the verification procedure described in Section 3.3. As described in the verification procedure, it is possible to prove our learned recursive program generalizes perfectly by testing on an appropriate set of problem inputs, i.e., the verification set. Recall that this verification procedure cannot be performed for the non-recursive versions, since the propagation of the hidden state in the core LSTM module makes reasoning difficult and so we would need to check an unbounded number of examples.
+
+We describe the base cases, reduction rules, and the verification set for each task in Appendix A.6. For each task, given the verification set, we check the traces and results of the learned, to-be-verified neural program (described in Section 4.1; and for bubble sort, Appendix A.6) on the verification set, and ensure they match the traces produced by the true program $P$ . Our results show that for all learned, to-be-verified neural programs, they all produced the same traces as those produced by $P$ on the verification set. Thus, we demonstrate that recursion enables provably perfect generalization for different tasks, including addition, topological sort, quicksort, and a variant of bubble sort.
+
+Note that the training set can often be considerably smaller than the verification set, and despite this, the learned model can still pass the entire verification set. Our result shows that the training procedure and the NPI architecture is capable of generalizing from the step input-output pairs seen in the training data to the unseen ones present in the verification set.
+
+# 5 CONCLUSION
+
+We emphasize that the notion of a neural recursive program has not been presented in the literature before: this is our main contribution. Recursion enables provably perfect generalization. To the best of our knowledge, this is the first time verification has been applied to a neural program, providing provable guarantees about its behavior. We instantiated recursion for the Neural ProgrammerInterpreter by changing the training traces. In future work, we seek to enable more tasks with recursive structure. We also hope to decrease supervision, for example by training with only partial or non-recursive traces, and to develop novel Neural Programming Architectures integrated directly with a notion of recursion.
+
+# ACKNOWLEDGMENTS
+
+This material is in part based upon work supported by the National Science Foundation under Grant No. TWC-1409915, DARPA under Grant No. FA8750-15-2-0104, and Berkeley Deep Drive. Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of National Science Foundation and DARPA.
+
+# REFERENCES
+
+Marcin Andrychowicz and Karol Kurach. Learning efficient algorithms with hierarchical attentive memory. CoRR, abs/1602.03218, 2016. URL http://arxiv.org/abs/1602.03218.
+
+Alex Graves, Greg Wayne, and Ivo Danihelka. Neural turing machines. CoRR, abs/1410.5401, 2014. URL http://arxiv.org/abs/1410.5401.
+
+Alex Graves, Greg Wayne, Malcolm Reynolds, Tim Harley, Ivo Danihelka, Agnieszka GrabskaBarwiska, Sergio Gmez Colmenarejo, Edward Grefenstette, Tiago Ramalho, John Agapiou, Adri Puigdomnech 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. ISSN 0028-0836, 1476-4687. doi: 10.1038/nature20101. URL http://www.nature.com/doifinder/10.1038/nature20101.
+
+Lukasz Kaiser and Ilya Sutskever. Neural gpus learn algorithms. CoRR, abs/1511.08228, 2015. URL http://arxiv.org/abs/1511.08228.
+
+Karol Kurach, Marcin Andrychowicz, and Ilya Sutskever. Neural random access machines. ERCIM News, 2016(107), 2016. URL http://ercim-news.ercim.eu/en107/special/ neural-random-access-machines.
+
+Arvind Neelakantan, Quoc V. Le, and Ilya Sutskever. Neural programmer: Inducing latent programs with gradient descent, 2015.
+
+Scott Reed and Nando de Freitas. Neural programmer-interpreters. ICLR, 2016.
+
+Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems 28: Annual Conference on Neural Information Processing Systems 2015, December 7-12, 2015, Montreal, Quebec, Canada, pp. 2692–2700, 2015. URL http://papers.nips.cc/paper/5866-pointer-networks.
+
+Wojciech Zaremba, Tomas Mikolov, Armand Joulin, and Rob Fergus. Learning simple algorithms from examples. In Proceedings of the 33nd International Conference on Machine Learning, ICML 2016, New York City, NY, USA, June 19-24, 2016, pp. 421–429, 2016. URL http://jmlr. org/proceedings/papers/v48/zaremba16.html.
+
+A APPENDIX
+
+A.1 PROGRAM SET FOR NON-RECURSIVE TOPOLOGICAL SORT   
+
+<table><tr><td rowspan=1 colspan=1>Program</td><td rowspan=1 colspan=1>Descriptions</td><td rowspan=1 colspan=1>Calls</td><td rowspan=1 colspan=1>Arguments</td></tr><tr><td rowspan=1 colspan=1>TOPOSORT</td><td rowspan=1 colspan=1>Perform topologicalsort on graph</td><td rowspan=1 colspan=1>TRAVERSE,NEXT_START,WRITE,MOVE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>TRAVERSE</td><td rowspan=1 colspan=1>Traverse graph untilstack is empty</td><td rowspan=1 colspan=1>CHECK_CHILD，EX-PLORE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>CHECK_CHILD</td><td rowspan=1 colspan=1>Check ifawhitechild exists; if so, setchildList[Uactive] topoint to it</td><td rowspan=1 colspan=1>MOVE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>EXPLORE</td><td rowspan=1 colspan=1>Repeatedlytraversesubgraphs until stackis empty</td><td rowspan=1 colspan=1>STACK,CHECK_CHILD,WRITE,MOVE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>STACK</td><td rowspan=1 colspan=1>Interactwith stack,either pushing orpopping</td><td rowspan=1 colspan=1>WRITE,MOVE</td><td rowspan=1 colspan=1>PUSH,POP</td></tr><tr><td rowspan=1 colspan=1>NEXT_START</td><td rowspan=1 colspan=1>Move Pstart untilreaching a whitevertex. If a whitevertex is found，setPstart to point to it;this signifies the startof a traversal of anew connected com-ponent.If no whitevertex is found, theentireexecution isterminated</td><td rowspan=1 colspan=1>MOVE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>WRITE</td><td rowspan=1 colspan=1>Write a value eitherto environment (e.g.,to color a vertex)or variable (e.g., tochange the value ofUactive)</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>Described below</td></tr><tr><td rowspan=1 colspan=1>MOVE</td><td rowspan=1 colspan=1>Move  a  pointer(e.g,   Pstart  orchildList[vactive])up or down</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>Described below</td></tr></table>
+
+# Argument Sets for WRITE and MOVE.
+
+WRITE. The WRITE operation has the following arguments:
+
+# ARG 1 (Main Action): COLOR CURR, COLOR NEXT, ACTIVE START, ACTIVE NEIGHB, ACTIVE STACK, SAVE, STACK PUSH, STACK POP, RESULT
+
+COLOR CURR colors $v _ { a c t i v e }$ , COLOR NEXT colors Vertex $D A G [ v _ { a c t i v e } ] [ c h i l d L i s t [ v _ { a c t i v e } ] ] ,$ , ACTIVE START writes pstart to $v _ { a c t i v e }$ , ACTIVE NEIGHB writes $D A G [ v _ { a c t i v e } ] [ c h i l d L i s t [ v _ { a c t i v e } ] ]$ to $v _ { a c t i v e }$ , ACTIVE STACK writes $Q _ { s t a c k } ( p _ { s t a c k } )$ to $v _ { a c t i v e }$ , SAVE writes $v _ { a c t i v e }$ to $v _ { s a v e }$ , $S T A C K \_ P U S H$ pushes $v _ { a c t i v e }$ to the top of the stack, $S T A C K \_ P O P$ writes a null value to the top of the stack, and $R E S U L T$ writes $v _ { a c t i v e }$ to $Q _ { r e s u l t } ( p _ { r e s u l t } )$ .
+
+ARG 2 (Auxiliary Variable): COLOR GREY, COLOR BLACK
+
+COLOR GREY and COLOR BLACK color the given vertex grey and black, respectively.
+
+MOVE. The MOVE operation has the following arguments:
+
+ARG 1 (Pointer): $p _ { r e s u l t } , p _ { s t a c k } , p _ { s t a r t } , c h i l d L i s t [ v _ { a c t i v e } ] , c h i l d L i s t [ v _ { s a v e } ]$
+
+Note that the argument is the identity of the pointer, not what the pointer points to; in other words, ARG 1 can only take one of 5 values.
+
+ARG 2 (Increment or Decrement): UP, DOWN
+
+# A.2 TRACE-GENERATING FUNCTIONS FOR TOPOLOGICAL SORT
+
+# A.2.1 NON-RECURSIVE TRACE-GENERATING FUNCTIONS
+
+1 // Top level topological sort call   
+2 TOPOSORT() {   
+3 while $( Q _ { c o l o r } \big ( p _ { s t a r t } \big )$ is a valid color): // color invalid when all vertices explored   
+4 WRITE(ACTIVE_START)   
+5 WRITE(COLOR_CURR, COLOR_GREY)   
+6 TRAVERSE()   
+7 MOVE(pstart, UP)   
+8 NEXT_START()   
+9 }   
+10   
+11 TRAVERSE() {   
+12 CHECK_CHILD()   
+13 EXPLORE()   
+14 }   
+15   
+16 CHECK_CHILD() {   
+17 while $( Q _ { c o l o r } \big ( D A G \big [ v _ { a c t i v e } \big ] \big [ c h i l d L i s t \big [ v _ { a c t i v e } \big ] \big ] \big )$ is not white and is not invalid): // color invalid when all children explored   
+18 MOVE(childList[vactive], UP)   
+19 }   
+20   
+21 EXPLORE() {   
+22 do   
+23 if (Qcolor(DAG[vactive][childList[vactive]]) is white):   
+24 WRITE(COLOR_NEXT, COLOR_GREY)   
+25 STACK(PUSH)   
+26 WRITE(SAVE)   
+27 WRITE(ACTIVE_NEIGHB)   
+28 MOVE(childList[vsave], UP)   
+29 else:   
+30 WRITE(COLOR_CURR, COLOR_BLACK)   
+31 WRITE(RESULT)   
+32 MOVE(presult, UP)   
+33 if(pstack == 1):   
+34 break   
+35 else:   
+36 STACK(POP)   
+37 CHECK_CHILD()   
+38 while (true)   
+39   
+40   
+41 STACK(op) {   
+42 if (op == PUSH):   
+43 WRITE(STACK_PUSH)   
+44 MOVE(pstack, UP)   
+45   
+46 if (op == POP):   
+47 WRITE(ACTIVE_STACK)   
+48 WRITE(STACK_POP)   
+49 MOVE(pstack, DOWN)   
+50 }   
+51   
+52 NEXT_START() {   
+53 while(Qcolor(pstart) is not white and is not invalid): // color invalid when all vertices explored   
+54 MOVE(pstart, UP)   
+55 }
+
+# A.2.2 RECURSIVE TRACE-GENERATING FUNCTIONS
+
+# Altered Recursive Functions
+
+1 // Top level topological sort call   
+2 TOPOSORT() {   
+3 if $\scriptstyle : Q _ { c o l o r }$ $_ { p _ { s t a r t } } ,$ is a valid color): // color invalid when all vertices explored   
+4 WRITE(ACTIVE_START)   
+5 WRITE(COLOR_CURR, COLOR_GREY)   
+6 TRAVERSE()   
+7 MOVE(pstart, UP)   
+8 NEXT_START()   
+9 TOPOSORT() // Recursive Call   
+10 }   
+11   
+12 CHECK_CHILD() {   
+13 if $\overline { { ( Q _ { c o l o r } ( D A G [ v _ { a c t i v e } ] [ c h i l d L i s t [ v _ { a c t i v e } ] ] ) } } ) \overline { { { } } }$ is not white and is not invalid): // color invalid when all children explore   
+14 MOVE(childList[vactive], UP)   
+15 CHECK_CHILD() // Recursive Call   
+16 }   
+17   
+18 EXPLORE() {   
+19 if (Qcolor(DAG[vactive][childList[vactive]]) is white):   
+20 WRITE(COLOR_NEXT, COLOR_GREY)   
+21 STACK(PUSH)   
+22 WRITE(SAVE)   
+23 WRITE(ACTIVE_NEIGHB)   
+24 MOVE(childList[vsave], UP)   
+25 else:   
+26 WRITE(COLOR_CURR, COLOR_BLACK)   
+27 WRITE(RESULT)   
+28 MOVE(presult, UP)   
+29 if $( p _ { s t a c k } = = 1$ ):   
+30 return   
+31 else:   
+32 STACK(POP)   
+33 CHECK_CHILD()   
+34 EXPLORE() // Recursive Call   
+35 }   
+36   
+37 NEXT_START() {   
+38 if $( Q _ { c o l o r } \left( p _ { s t a r t } \right)$ is not white and is not invalid): // color invalid when all vertices explored   
+39 MOVE $( p _ { s t a r t }$ , UP)   
+40 NEXT_START() // Recursive Call   
+41 }
+
+# Algorithm 4 Iterative Quicksort
+
+1: Initialize an array $A$ to sort and two empty stacks $S _ { l o }$ and $S _ { h i }$ .   
+2: Initialize lo and $h i$ to be 1 and $n$ , where $n$ is the length of $A$ .   
+3:   
+4: function PARTITION $( A , l o , h i )$   
+5: $p i v o t = l o$   
+6: for $j \in [ l o , h i - 1 ] : \mathbf { d o }$   
+7: if $A [ j ] \leq A [ h i ]$ then   
+8: swap A[pivot] with $A [ j ]$   
+9: pivot = pivot + 1   
+10: swap A[pivot] with $A [ h i ]$   
+11: return pivot   
+12:   
+13: function QUICK ${ \mathrm { : } } \operatorname { S o R T } ( A , l o , h i )$   
+14: while $S _ { l o }$ and $S _ { h i }$ are not empty: do   
+15: Pop states off $S _ { l o }$ and $S _ { h i }$ , writing them to $l o$ and $h i$ .   
+16: $\mathsf { p } = \mathsf { P A R T I T I O N } ( A , l o , h i )$   
+17: Push $p + 1$ and $h i$ to $S _ { l o }$ and $S _ { h i }$ .   
+18: Push lo and $p - 1$ to $S _ { l o }$ and $S _ { h i }$ .
+
+A.4 PROGRAM SET FOR QUICKSORT   
+
+<table><tr><td rowspan=1 colspan=1>Program</td><td rowspan=1 colspan=1>Descriptions</td><td rowspan=1 colspan=1>Calls</td><td rowspan=1 colspan=1> Arguments</td></tr><tr><td rowspan=1 colspan=1>QUICKSORT</td><td rowspan=1 colspan=1>Runthequicksortroutine in place forthearrayA，forindices from lo to hi</td><td rowspan=1 colspan=1>Non-Recursive: PAR-TITION,     STACK,WRITERecursive:  same asnon-recursiveversion,alongwithQUICK-SORT</td><td rowspan=1 colspan=1>Implicitly:arrayA to sort, lo, hi</td></tr><tr><td rowspan=1 colspan=1>PARTITION</td><td rowspan=1 colspan=1>Runsthepartitionfunction.  At end,pointer Ppivot  ismoved to the pivot</td><td rowspan=1 colspan=1>COMPSWAP_LOOP,MOVE_PIVOT_LO,MOVE_JLO, SWAP</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>COMPSWAPLOOP</td><td rowspan=1 colspan=1>Runs the FOR loopinside the partitionfunction</td><td rowspan=1 colspan=1>COMPSWAP, MOVE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>COMPSWAP</td><td rowspan=1 colspan=1>ComparesA[pivot] ≤ A[j]; ifso,perform a swapand increment Ppivot</td><td rowspan=1 colspan=1>SWAP, MOVE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>SET_PIVOTLO</td><td rowspan=1 colspan=1>Sets Ppivot to lo in-dex</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>SETJLO</td><td rowspan=1 colspan=1>Sets pj to lo index</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>SET_J_NULL</td><td rowspan=1 colspan=1>Sets pj to-00</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>NONE</td></tr><tr><td rowspan=1 colspan=1>STACK</td><td rowspan=1 colspan=1>Pushes lo/hi statesonto stacks Sto andShi according to argument(describedbelow)</td><td rowspan=1 colspan=1>WRITE, MOVE</td><td rowspan=1 colspan=1>Described below</td></tr><tr><td rowspan=1 colspan=1>MOVE</td><td rowspan=1 colspan=1>Movespointerone unit up or down</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>Described below</td></tr><tr><td rowspan=1 colspan=1>SWAP</td><td rowspan=1 colspan=1>Swapselementsatgiven array indices</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>Described below</td></tr><tr><td rowspan=1 colspan=1>WRITE</td><td rowspan=1 colspan=1>Write   a   valueeither  to  stack(e.g QstackLoorQstackHi)  or  topointer (e.g  tochangethe value ofPhi)</td><td rowspan=1 colspan=1>NONE</td><td rowspan=1 colspan=1>Described below</td></tr></table>
+
+Argument Sets for STACK, MOVE, SWAP, WRITE.
+
+STACK. The STACK operation has the following arguments:
+
+ARG 1 (Operation): STACK PUSH CALL1, STACK PUSH CALL2, STACK POP
+
+STACK PUSH CALL1 pushes $l o$ and pivot−1 to $Q _ { s t a c k L o }$ and $Q _ { s t a c k H i }$ . STACK PUSH CALL2 pushes pivot $+ 1$ and $h i$ to $Q _ { s t a c k L o }$ and $Q _ { s t a c k H i }$ . STACK POP pushes $- \infty$ values to $Q _ { s t a c k L o }$ and $Q _ { s t a c k H i }$ .
+
+MOVE. The MOVE operation has the following arguments:
+
+ARG 1 (Pointer): pstackLo, pstackHi, pj , ppivot
+
+Note that the argument is the identity of the pointer, not what the pointer points to; in other words, ARG 1 can only take one of 4 values.
+
+ARG 2 (Increment or Decrement): UP, DOWN
+
+SWAP. The SWAP operation has the following arguments:
+
+ARG 1 (Swap Object 1): ppivot
+
+ARG 2 (Swap Object 2): $p _ { h i } , p _ { j }$
+
+WRITE. The WRITE operation has the following arguments:
+
+ARG 1 (Object to Write): ENV STACK LO, ENV STACK HI, $p _ { h i } , p _ { l o }$
+
+ENV STACK LO and ENV STACK HI represent $Q _ { s t a c k L o } ( p _ { s t a c k L o } ) $ and $Q _ { s t a c k H i } ( p _ { s t a c k H i } )$ , re spectively.
+
+ARG 2 (Object to Copy): ENV STACK LO PEEK, ENV STACK HI PEEK, $p _ { h i } , p _ { l o } , p _ { p i v o t } - 1$ ppivot + 1, RESET
+
+ENV STACK LO PEEK and ENV STACK HI PEEK represent $Q _ { s t a c k L o } ( p _ { s t a c k L o } \mathrm { ~ - ~ } 1 )$ and $Q _ { s t a c k H i } ( p _ { s t a c k H i } - 1 )$ , respectively. RESET represents a $- \infty$ value.
+
+Note that the argument is the identity of the pointer, not what the pointer points to; in other words, ARG 1 can only take one of 4 values, and ARG 2 can only take one of 7 values.
+
+# A.5 TRACE-GENERATING FUNCTIONS FOR QUICKSORT
+
+# A.5.1 NON-RECURSIVE TRACE-GENERATING FUNCTIONS
+
+1 Initialize $p _ { l o }$ to 1 and $p _ { h i } \ t \circ \ n$ (length of array)   
+2 Initialize $p _ { j } ~ \mathsf { t o } ~ - \infty$   
+3   
+4 QUICKSORT() {   
+5 while $( p _ { s t a c k L o } \neq 1 )$ :   
+6 if $( \stackrel {  } { Q } _ { s t a c k L o } ^ { \prime \prime } ( \stackrel { \prime } { p } _ { s t a c k L o } - 1 ) < Q _ { s t a c k H i } ( p _ { s t a c k H i } - 1 ) ) :$   
+7 STACK(STACK_POP)   
+8 else:   
+9 WRITE $( \boldsymbol { p } _ { h i }$ , ENV_STACK_HI_PEEK)   
+10 WRITE(plo, ENV_STACK_LO_PEEK)   
+11 STACK(STACK_POP)   
+12 PARTITION()   
+13 STACK(STACK_PUSH_CALL2)   
+14 STACK(STACK_PUSH_CALL1)   
+15 }   
+16   
+17 PARTITION() {   
+18 SET_PIVOT_LO()   
+19 SET_J_LO()   
+20 COMPSWAP_LOOP()   
+24 SWAP(ppivot, phi)   
+SET_J_NULL()   
+}   
+COMPSWAP_LOOP() {   
+while $( p _ { j } \neq p _ { h i } )$ :   
+COMPSWAP()   
+MOVE $( p _ { j }$ , UP)   
+}   
+30   
+31 COMPSWAP() {   
+32 if (A[pj ] ≤ A[phi]):   
+33 SWAP(ppivot, pj)   
+34 MOVE(ppivot, UP)   
+35 }   
+36   
+37 STACK(op) {   
+38 if (op == STACK_PUSH_CALL1):   
+39 WRITE(ENV_STACK_LO, plo)   
+40 WRITE(ENV_STACK_HI, ppivot − 1)   
+41 MOVE(pstackLo, UP)   
+42 MOVE(pstackHi, UP)   
+43   
+44 if (op $= =$ STACK_PUSH_CALL2):   
+45 WRITE(ENV_STACK_LO, ppivot $^ { + 1 1 }$ )   
+46 WRITE(ENV_STACK_HI, $p _ { h i }$ )   
+47 MOVE(pstackLo, UP)   
+48 MOVE(pstackHi, UP)   
+49   
+50 if (op $= =$ STACK_POP):   
+51 WRITE(ENV_STACK_LO, RESET)   
+52 WRITE(ENV_STACK_HI, RESET)   
+53 MOVE(pstackLo, DOWN)   
+54 MOVE(pstackHi, DOWN)   
+55 }
+
+# A.5.2 RECURSIVE TRACE-GENERATING FUNCTIONS
+
+# Altered Recursive Functions
+
+Initialize to 1 and $p _ { h i } \ t \circ \ n$ (length of array)
+
+1 $p _ { l o }$   
+2 Initialize $p _ { j }$ to −∞   
+3   
+4 QUIC $\begin{array} { r l } & { \mathrm { \sf { A S O R T } \left( \tau \right) } \quad \mathrm { \sf { \{ } } }  \\ & { \mathrm { \sf { ( } } Q _ { s t a c k L o } ( p _ { s t a c k L o } - 1 ) < Q _ { s t a c k H i } ( p _ { s t a c k H i } - 1 ) ) : } \\ & { \mathrm { \sf { 2 } } \mathrm { \sf { A R T I T I O N } \left( \tau \right) } } \end{array}$   
+5 if   
+6   
+7 STACK(STACK_PUSH_CALL2)   
+8 STACK(STACK_PUSH_CALL1)   
+9 WRITE $( p _ { h i }$ , ENV_STACK_HI_PEEK)   
+10 WRITE $( p _ { l o }$ , ENV_STACK_LO_PEEK)   
+11 QUICKSORT() // Recursive Call   
+12 STACK(STACK_POP)   
+13 WRITE $( p _ { h i }$ , ENV_STACK_HI_PEEK)   
+14 WRITE $( p _ { l o }$ , ENV_STACK_LO_PEEK)   
+15 QUICKSORT() // Recursive Call   
+16 STACK(STACK_POP)   
+17 }   
+18   
+19 COMPSWAP_LOOP() {   
+20 if $( p _ { j } \neq p _ { h i } )$ :   
+21 COMPSWAP()   
+22 MOVE $( p _ { j }$ , UP)   
+23 COMPSWAP_LOOP() // Recursive Call   
+24 }
+
+A.6 BASE CASES, REDUCTION RULES, AND VERIFICATION SETS
+
+In this section, we describe the space of base cases and reduction rules that must be covered for each of the four sample tasks, in order to create the verification set.
+
+For addition, we analytically determine the verification set. For tasks other than addition, it is difficult to analytically determine the verification set, so instead, we randomly generate input candidates until they completely cover the base cases and reduction rules.
+
+Base Cases and Reduction Rules for Addition. For the recursive formulation of addition, we analytically construct the set of input problems that cover all base cases and reduction rules. We outline how to construct this set.
+
+It is sufficient to construct problems where every transition between two adjacent columns is covered. The ADD reduction rule ensures that each call to ADD only covers two adjacent columns, and so the LSTM only ever runs for a fixed number of steps necessary to process these two columns.
+
+We construct input problems by splitting into two cases: one case in which the left column contains a null value and another in which the left column does not contain any null values. We then construct problem configurations that span all possible valid environment states (for instance, in order to force the carry bit in a column to be 1, one can add the sum $\cdot _ { 1 + 9 } ,$ in the column to the right).
+
+The operations we need to be concerned most about are CARRY and LSHIFT, which induce partial environment states spanning two columns. It is straightforward to deal with all other operations, which do not induce partial environment states.
+
+Under the assumption that there are no leading 0’s (except in the case of single digits) and the two numbers to be added have the same number of digits, the verification set for addition contains 20,181 input problems. The assumption of leading 0’s can be easily removed, at the cost of slightly increasing the size of the verification set. We made the assumption of equivalent lengths in order to parametrize the input format with respect to length, but this assumption can be removed as well.
+
+Base Cases and Reduction Rules for Bubble Sort. The original version of the bubblesort implementation exposes the values within the array. While this matches the description from Reed & de Freitas (2016), we found that this causes an unnecessary blowup in the size of $V$ and makes it much more difficult to construct the verification set. For purposes of verification, we replace the domain-specific encoder with the following:
+
+$$
+\begin{array} { r l } & { f _ { e n c } ( Q , i _ { 1 } , i _ { 2 } , i _ { 3 } , a _ { t } ) = M L P ( [ Q ( 1 , i _ { 1 } ) \leq Q ( 1 , i _ { 2 } ) , 1 \leq i _ { 1 } \leq l e n g t h , 1 \leq i _ { 2 } \leq l e n g t h , } \\ & { ~ i _ { 3 } = = l e n g t h , a _ { t } ( 1 ) , a _ { t } ( 2 ) , a _ { t } ( 3 ) ] ) , } \end{array}
+$$
+
+Table 4: Accuracy on Randomly Generated Problems for Variant of Bubble Sort   
+
+<table><tr><td>Length of Array</td><td>Non-Recursive</td><td>Recursive</td></tr><tr><td></td><td>100%</td><td>100%</td></tr><tr><td>２3</td><td>100%</td><td>100%</td></tr><tr><td>4</td><td>100%</td><td>100%</td></tr><tr><td>5</td><td>100%</td><td>100%</td></tr><tr><td>6</td><td>90%</td><td>100%</td></tr><tr><td>7</td><td>86.7%</td><td>100%</td></tr><tr><td>8</td><td>6.7%</td><td>100%</td></tr><tr><td>9</td><td>0%</td><td>100%</td></tr><tr><td>10</td><td>0%</td><td></td></tr><tr><td>12</td><td>0%</td><td>100%</td></tr><tr><td>15</td><td>0%</td><td>100%</td></tr><tr><td></td><td></td><td>100%</td></tr><tr><td>70</td><td>0%</td><td>100%</td></tr></table>
+
+which directly exposes which of the two values pointed to is larger. This modification also enables us to sort arrays containing arbitrary comparable elements.
+
+By reasoning about the possible set of environment observations created by all valid inputs, we construct $V$ using the procedure described in Section 3.3. Using this modification, we constructed a verification set consisting of one array of size 10.
+
+We also report on generalization results for the non-recursive and recursive versions of this variant of bubble sort. Table 4 demonstrates that the accuracy of the non-recursive program degrades sharply when moving from arrays of length 7 to arrays of length 8. This is due to the properties of the training set – we trained on 2 traces synthesized from arrays of length 7 and 1 trace synthesized from an array of length 6. Table 4 also demonstrates that the (verified) recursive program generalizes perfectly.
+
+Base Cases and Reduction Rules for Topological Sort. For each function we use to implement the recursive version of topological sort, we need to consider the set of possible environment observation sequences we can create from all valid inputs and test that the learned program produces the correct behavior on each of these inputs. We have three observations: the color of the start node, the color of the active node’s next child to be considered, and whether the stack is empty. Na¨ıvely, we might expect to synthesize and test an input for any sequence created by combining the four possible colors in two variables and another boolean variable for whether the stack is empty (so 32 possible observations at any point), but for various reasons, most of these combinations are impossible to occur at any given point in the execution trace.
+
+Through careful reasoning about the possible set of environment observations created by all valid inputs, and how each of the operations in the execution trace affects the environment, we can construct $V$ using the procedure described in Section 3.3. We then construct a verification set of size 73 by ensuring that randomly generated graphs cover the analytically derived $V$ . The model described in the training setup of Section 4 (trained on 6 traces) was verified to be correct via the matching procedure described in Section 4.2.
+
+Base Cases and Reduction Rules for Quicksort. As with the others, we apply the procedure described in Section 3.3 to construct $V$ and then empirically create a verification set which covers $V$ . The verification set can be very small, as we found a 10-element array ([8,2,1,2,0,8,5,8,3,7]) is sufficient to cover all of $V$ . We note that an earlier version of quicksort we tried lacked primitive operations to directly move a pointer to another, and therefore needed more functions and observations. As this complexity interfered with determining the base cases and reductions, we changed the algorithm to its current form. Even though the earlier version also generalized just as well in practice, relatively small differences in the formulation of the traces and the environment observations can drastically change the difficulty of verification.

parse/train/BygZK2VYvB/BygZK2VYvB.md

@@ -0,0 +1,316 @@
+# Utilizing Edge Features in Graph Neural Networks via Variational Information Maximization
+
+Anonymous authors Paper under double-blind review
+
+# Abstract
+
+Graph Neural Networks (GNNs) broadly follow the scheme that the representation vector of each node is updated recursively using the message from neighbor nodes, where the message of a neighbor is usually pre-processed with a parameterized transform matrix. To make better use of edge features, we propose the Edge Information maximized Graph Neural Network (EIGNN) that maximizes the Mutual Information (MI) between edge features and message passing channels. The MI is reformulated as a differentiable objective via a variational approach. We theoretically show that the newly introduced objective enables the model to preserve edge information, and empirically corroborate the enhanced performance of MI-maximized models across a broad range of learning tasks including regression on molecular graphs and relation prediction in knowledge graphs.
+
+# 1 Introduction
+
+Many real-world datasets naturally come in the form of graphs, such as citation networks (Kipf & Welling, 2017), social networks Hamilton et al. (2017), knowledge graphs (Schlichtkrull et al., 2018), molecular graphs (Scarselli et al., 2009; Duvenaud et al., 2015) etc., all of which consist of a number of nodes and edges equipped with their inherent features. Recently, impressive performance has been achieved in graph learning tasks with various forms of Graph Neural Networks (GNNs) (Zhou et al., 2018). Compared to prior works, such as node2vec (Grover & Leskovec, 2016), GNNs learn the state of a node by recursively aggregating messages from its neighbors: combining the graph structure with node features. Intuitively, edge features should play an important role in graph learning tasks. For example, chemical bonds in a molecule have a high impact on chemical properties of molecules, and edge features in knowledge graphs encode important relations between concepts, data, and entities. Our proposed method focuses on improving the usage of edge features in GNNs.
+
+The expressive power of GNNs largely depends on how the message is passed between nodes. A widely adopted scheme is multiplying neighbor node states with a parameterized transform matrix before aggregation (Gilmer et al., 2017; Xu et al., 2019). Despite tremendous success of GNNs, existing models do not exhaustively exploit the full potentials of edge features on graphs. For example, many GNNs such as GCN (Kipf & Welling, 2017), ChebyNet (Defferrard et al., 2016) and GAT (Veličković et al., 2018) do not even consider categorized edge types. To utilize edge features in multi-relational graphs, RGCN (Schlichtkrull et al., 2018) proposes to learn a different transform matrix for each edge type, respectively. However, it does not generalize to edge features in continuous space. MPNN (Gilmer et al., 2017) introduces an edge network that takes edge feature vectors as input and outputs transform matrices, which are used to transform states of neighbor nodes. In principle, the MPNN framework can handle complex edge features. Yet, the lack of maximization of MI between edge and message channels implies that the MPNN may give an edge-independent transform matrix.
+
+In this work, we aim to more efficiently exploit the full potentials of edge features from the perspective of training. We propose the Edge Information maximized Graph Neural Network (EIGNN) that maximizes the Mutual Information (MI) between edge features and the message passing channel which is parameterized as the transform matrix in the widely-accepted message passing framework (transformation and aggregation) (Gilmer et al., 2017; Xu et al., 2019). Considering the challenge of computing the MI, we adopt a variational approach to reformulate it as an differentiable objective, which can be easily applied as a regularization term. We theoretically show that EIGNN can reduce information loss of edge features. Apart from demonstrating the impressive performance of EIGNN on extensive benchmarks of molecular graphs and knowledge graphs, we also analyze and attribute the enhanced effectiveness of EIGNN to the exploitation of edge features instead of the regularization effects. Notably, attribution analysis on molecular graphs show that EIGNN can capture domain knowledge without human interference.
+
+Preliminaries Let $G = ( \nu , \mathcal { E } )$ be a graph with node feature vectors $x _ { v } \in \mathbb { R } ^ { d }$ for node $v \in \nu$ and edge feature vectors $e _ { v w } \in \mathcal { E }$ for the edge connecting node $v$ and $w$ . In GNNs, the state of each node is updated recursively using neighbor nodes. Let $\mathcal { N } _ { v }$ be the set of neighbor nodes of $v$ and $h _ { v } ^ { ( l ) } \in \mathbb { R } ^ { d _ { l } }$ be the hidden state of $v$ at $\it l$ -th layer, where $d _ { l }$ is the dimension of the hidden layer. For simplicity of notation, we use a single $d$ to denote the dimension such that $h _ { v } ^ { ( l ) } \in \mathbb { R } ^ { d }$ . We also have $h _ { v } ^ { ( 0 ) } = x _ { v }$ at the input layer.
+
+# 2 Related works
+
+# 2.1 Relational Modeling in Graph Neural Networks
+
+Single-relational modeling. Many variants such as GCN (Kipf & Welling, 2017), GAT (Veličković et al., 2018), ChebyNet (Defferrard et al., 2016), GraphSAGE (Hamilton et al., 2017) focus on learning node states. These models can assign weight to neighbors, but they can not handle various edge features. A typical neighborhood aggregation scheme is
+
+$$
+h _ { v } ^ { ( l + 1 ) } = \sigma \left( \sum _ { w \in \mathcal { N } _ { v } } \alpha _ { v w } W _ { 1 } ^ { ( l ) } h _ { w } ^ { ( l ) } + W _ { 0 } ^ { ( l ) } h _ { v } ^ { ( l ) } \right) ,
+$$
+
+where $\sigma$ denotes an activation function, $\alpha _ { v w }$ can be a normalization constant or a learned attention coefficient (Veličković et al., 2018). States of all neighbors are multiplied by the same trainable transform matrix $W _ { 1 } ^ { ( l ) }$ . Sometimes the self-connection is also treated in the same way, s.t., W (l)0 = W (l)1 .
+
+Multi-relational modeling. A simple strategy to handle multi-relational graphs is assigning each edge type with a separate transform matrix as presented in RGCN (Schlichtkrull et al., 2018) and adopted by GGNN (Li et al., 2016) and LNet (Liao et al., 2019). RGCN updates node states according to the following scheme
+
+$$
+\begin{array} { r } { h _ { v } ^ { ( l + 1 ) } = \sigma \left( \sum _ { r \in \mathcal { R } } \sum _ { w \in \mathcal { N } _ { v } ^ { r } } \alpha _ { v w , r } W _ { r } ^ { ( l ) } h _ { w } ^ { ( l ) } + W _ { 0 } ^ { ( l ) } h _ { v } ^ { ( l ) } \right) , } \end{array}
+$$
+
+where $\mathcal { N } _ { v } ^ { r }$ is the collection of neighboring nodes of $\boldsymbol { v }$ with relation $r \in \mathcal { R }$ and $\alpha _ { v w , r }$ is a normalization constant similar as $\alpha _ { v w }$ in Eq. (1). Such a scheme faces challenge in handling edge features of continuous space. GGNN and LNet do not focus on the improvement of edge expressibility. GGNN introduces Gated Recurrent Unit (GRU) (Cho et al., 2014) and LNet focus on handling multi-scale connections.
+
+Complex-relational modeling. The relation in a graph can be quite complex, expressed as a general feature vector $e$ . MPNN (Gilmer et al., 2017) introduces an edge network which takes edge feature vectors as input and outputs transform matrices. A single edge network is shared in a MPNN model. The forward propagation is formalized as
+
+$$
+m _ { v } ^ { ( l + 1 ) } = \sigma \left( \sum _ { w \in \mathcal { N } _ { v } } f ( e _ { v w } ) h _ { w } ^ { ( l ) } + W _ { 0 } ^ { ( l ) } h _ { v } ^ { ( l ) } \right) , \quad h _ { v } ^ { ( l + 1 ) } = \mathrm { G R U } ( h _ { v } ^ { ( l ) } , m _ { v } ^ { ( l + 1 ) } ) ,
+$$
+
+where $f : e  W$ denotes the edge network. Recently, some research works treat a multirelational problem as the complex-relational one by introducing a continuous edge embedding vector for each edge type, so as to handle increasing number of relations (Nathani et al., 2019). Although the MPNN architecture allows the usage of arbitrary edge features, this advantage is not utilized in practice. MPNN can actually learn an edge-independent transform matrix. A GNN model that efficiently utilizes edge features is yet to emerge.
+
+# 2.2 Readout functions
+
+After several forward propagations, GNNs yield final states of all nodes, which are suitable for node/edge classification or regression. For graph classification or regression tasks, we can apply a readout function (Ying et al., 2018; Vinyals et al., 2015) such that
+
+$$
+y = R ( \{ h _ { v } ^ { L } | v \in G \} ) ,
+$$
+
+where $h _ { v } ^ { L }$ is the state of $v$ at the last layer, $R$ is the readout function that outputs a graph-level representation $y$ , e.g., summing up the final node states, applying hierarchical pooling (Ying et al., 2018) or using the set2set model (Vinyals et al., 2015).
+
+# 3 Our method
+
+# 3.1 The Usage of Mutual Information
+
+In probability theory and information theory, MI is a measure of mutual dependence between two random variables. Our method proposes to preserve edge information in GNNs, which is important in many real-world graph structures such as molecules - apart from node (atom) features, attributes of edges (bonds) are equally important for predicting properties of molecules. To this end, we maximize $I ( e ; W )$ - the MI between the edge feature vector $e$ and the message passing channel, i.e., the transform matrix $W$ which is used to transform neighbor node states in the forward propagation. Our method can be easily generalized to directly maximize the MI between edge features and the message itself in methods that do not explicitly have the transform matrix, e.g., the message from node $w$ to node $v$ can be expressed as $f ( h _ { v } , e _ { v w } , h _ { w } )$ rather than $f ( e _ { v w } ) h _ { w }$ , which is shown in Section 4.3.
+
+An general principle of maximum MI is described for unsupervised learning task by (Linsker, 1988) and MI inspired objective functions have long been adopted in unsupervised learning (Bridle et al., 1992; Barber & Agakov, 2006; Veličković et al., 2019; Hjelm et al., 2019), semi-supervised learning (Krause et al., 2010) and generative adversarial networks (Chen et al., 2016). Specifically, DGI (Veličković et al., 2019) also applies MI to GNNs. DGI proposes to learn node-wise representations in an unsupervised manner by maximizing the MI between node representations and corresponding high-level summaries of graphs, using adversarial learning and negative sampling. The node representations may then be retrieved and used for downstream tasks, such as node classification. DGI can be used to pre-train GNNs, as demonstrated in Hu et al. (2019). Our EIGNN also proposes information maximization but targets a completely different objective and adopts a quite different approach.
+
+# 3.2 A Variational Approach to Maximize Mutual Information
+
+Computing $I ( e ; W )$ itself is intractable in practice, needless to say that training a model requires the derivative. Thus, we adopt a variational approach (Agakov, 2004) to reformulate $I ( e ; W )$ as a differentiable objective. We show that our objective is an approximated lower bound of $I ( e ; W )$ and notably, optimizing our objective does lead to maximizing $I ( e ; W )$ . Following MPNN (Gilmer et al., 2017), we use an edge network to parameterize the transform matrix $W$ and relate it to edge features. Therefore, the prior $p ( W | e )$ is
+
+$$
+p ( W | e ) = \delta ( W - f ( e ) ) ,
+$$
+
+where $\delta ( \cdot )$ is the Dirac delta function. The posterior $p ( e | W )$ is intractable, so we define a variational distribution $q ( e | W )$ , which can be obtained by defining a neural network $g : W \to e$ Specifically, $q ( e | W )$ substitutes to some distribution (such as Gaussian distribution) with parameter $g ( W )$ . In this way, $f$ and $g$ are similar to the probabilistic encoder and decoder in the Variational Auto-Encoder (VAE) (Kingma $\&$ Welling, 2013). Then we can approximate $I ( e ; W )$ with a differentiable objective $L _ { I } ( f , g ; e )$ as follows.
+
+Theorem 1. Let e be the edge feature vector, $W$ be the transform matrix with conditional distribution $p ( W | e )$ specified by the probabilistic encoder $f$ as shown in Eq. (5) and $q ( e | W )$ be the variational distribution specified by the probabilistic decoder $g$ , then we have
+
+$$
+I ( e ; W ) \geq H ( e ) + \mathbb { E } _ { e \sim p ( e ) } [ \mathcal { L } _ { I } ( f , g ; e ) ] ,
+$$
+
+where $\mathcal { L } _ { I } ( f , g ; e ) = \log q ( e | f ( e ) )$ and $H ( \cdot )$ denotes the entropy.
+
+Proof. Let $D _ { K L } ( \cdot \parallel \cdot )$ denote the KL-divergence, which should be nonnegative, then we have
+
+$$
+\begin{array} { r l } { I ( e ; W ) = H ( e ) - H ( e | W ) } & { } \\ { \ } & { = H ( e ) + \mathbb { E } _ { W \sim p ( W ) } [ \mathbb { E } _ { e \sim p ( e | W ) } [ \log p ( e | W ) ] ] } \\ { \ } & { = H ( e ) + \mathbb { E } _ { W \sim p ( W ) } [ \mathbb { E } _ { e \sim p ( e | W ) } [ \log p ( e | W ) - \log q ( e | W ) + \log q ( e | W ) ] ] } \\ { \ } & { = H ( e ) + \mathbb { E } _ { W \sim p ( W ) } [ D _ { K L } ( p ( e | W ) \| q ( e | W ) ) + \mathbb { E } _ { e \sim p ( e | W ) } [ \log q ( e | W ) ] ] } \\ { \ } & { \geq H ( e ) + \mathbb { E } _ { W \sim p ( W ) } [ \mathbb { E } _ { e \sim p ( e | W ) } [ \log q ( e | W ) ] ] } \\ { \ } & { = H ( e ) + \mathbb { E } _ { e \sim p ( e ) , W \sim p ( W | e ) } [ \log q ( e | W ) ] } \\ { \ } & { \stackrel { ( a ) } { = } H ( e ) + \mathbb { E } _ { e \sim p ( e ) } [ \log q ( e | f ( e ) ) ] } \end{array}
+$$
+
+where the equality ( $a$ ) follows from Eq. (5).
+
+According to Theorem 1, we can maximize the variational lower bound for $I ( e ; W )$ . The bound becomes tight when the variational distribution $q ( e | W )$ approaches the true posterior $p ( e | W )$ . Moreover, $H ( e )$ is a constant because the distribution of edge feature vector $e$ is fixed for given graphs, hence we can equivalently maximize $\mathcal { L } _ { I } ( f , g ; e )$ . We choose the widely accepted Gaussian distribution as the prior distribution for the probabilistic decoder $g$ ,
+
+$$
+q ( e | W ) = \mathcal { N } ( e ; g ( W ) , \sigma ^ { 2 } I ) .
+$$
+
+Then we have
+
+$$
+\mathcal { L } _ { I } ( f , g ; e ) = \log q ( e | f ( e ) ) = \log \mathcal { N } ( e ; g ( f ( e ) ) , \sigma ^ { 2 } I ) = - \lambda \| e - g ( f ( e ) ) \| _ { 2 } ^ { 2 }
+$$
+
+where $\lambda > 0$ is a constant determined by $\sigma$ and the dimension of $e$ , taken as a tunable parameter. The following Theorem 2 shows that maximizing the objective in Eq. (8) does lead to the maximization of $I ( e ; W )$ , hence enables the model to preserve edge information.
+
+Theorem 2. Assume the optimal solution of maximizing $\mathcal { L } _ { I } ( f , g ; e )$ is $f ^ { \star }$ and $g ^ { \star }$ , then $f ^ { \star }$ also maximizes $I ( e ; W )$ .
+
+Proof. Note that $H ( e )$ is a constant when the graphs are given. In information theory, we have
+
+$$
+H ( g ( f ( e ) ) ) \leq H ( f ( e ) ) \leq H ( e ) .
+$$
+
+$I ( e ; W )$ is upper bounded by $H ( e )$ ,
+
+$$
+I ( e ; W ) = I ( e ; f ( e ) ) = H ( f ( e ) ) - H ( f ( e ) | e ) = H ( f ( e ) ) \leq H ( e ) .
+$$
+
+Since $f ^ { \star }$ and $g ^ { \star }$ is the optimal solution of maximizing $\mathcal { L } _ { I } ( f , g ; e )$ presented in Eq. (8), it is not difficult to see that $e = g ^ { \star } ( f ^ { \star } ( e ) ) , \forall e \in \mathcal { E }$ . In this case, the inequalities in Eq. 9 become equalities, i.e.,
+
+$$
+H ( g ^ { \star } ( f ^ { \star } ( e ) ) ) = H ( f ^ { \star } ( e ) ) = H ( e ) .
+$$
+
+Therefore, we have $I ( e ; W ) = H ( e )$ , i.e., the maximum is attained in this case.
+
+3.3 Edge Information Maximized Graph Neural Networks
+
+Our EIGNN is derived by implementing our MI objective in GNNs. As a concrete example, the forward propagation of our model follows the formulation in Eq. (3), where the dege network $f : e  W$ is expressed as a multi-layer perceptron (MLP). According to theoretical analysis presented in Sec. 3.2 , we introduce another MLP $g : W \to e$ as the decoder.
+
+For graph regression or classification tasks, the model outputs a prediction $y$ for each graph $G$ , which has label $\hat { y }$ . Without MI maximization, we denote the vanilla loss as $\mathcal { L } _ { 0 } ( \hat { y } , y ; G )$ . Common choice of $\mathcal { L } _ { 0 }$ includes Mean Square Error (MSE), Mean Absolute Error (MAE) and Cross Entropy (CE). For a graph $G = ( \nu , \mathcal { E } )$ , EIGNN maximizes $\mathcal { L } _ { I } ( f , g ; e )$ and minimizes $\mathcal { L } _ { 0 } ( \hat { y } , y ; G )$ using the following loss function
+
+$$
+\mathcal { L } _ { E I G N N } ( G ) = \mathcal { L } _ { 0 } ( \hat { y } , y ; G ) - \lambda \mathbb { E } _ { e \in \mathcal { E } } [ \mathcal { L } _ { I } ( f , g ; e ) ] ,
+$$
+
+where $\mathbb { E } _ { e \in \mathcal { E } } [ \cdot ]$ denotes taking the mean over all edges in $G = ( \nu , \mathcal { E } )$ and $\lambda$ is the regularization parameter. When EIGNN is trained using mini-batches, $\mathcal { L } _ { 0 } ( \hat { y } , y ; G )$ is averaged over all graphs in the batch while $\mathcal { L } _ { I } ( f , g ; e )$ is averaged over all edges of all graphs in the batch.
+
+Similarly, for relational prediction tasks in knowledge graphs, EIGNN directly yields nodelevel representations $h _ { v }$ for each node $v \in \mathcal V$ and edge-level representations $e$ for each relationship. The objective function of EIGNN can be derived from the translational scoring function Bordes et al. (2013), which learns embedding such that for a given valid triple $t _ { v w } = ( h _ { v } , e _ { v w } , h _ { w } )$ from the valid set $S$ , the condition $d _ { t _ { v w } } = h _ { v } + e _ { v w } - h _ { w } \approx 0$ holds. Let $\mathcal { L } _ { 0 } = \mathbb { E } _ { t _ { v w } \in S } \mathbb { E } _ { t _ { v w } ^ { \prime } \in S ^ { \prime } } \operatorname* { m a x } \{ d _ { t _ { v w } ^ { \prime } } - d _ { t _ { v w } } + \gamma , 0 \}$ , where $S ^ { \prime }$ denotes a set of invalid triples and $\gamma$ is a margin hyper-parameter, EIGNN can be trained by minimizing the following loss,
+
+$$
+\mathcal { L } _ { E I G N N } ( G ) = \mathcal { L } _ { 0 } - \lambda \mathbb { E } _ { e \in \mathcal { E } } [ \mathcal { L } _ { I } ( f , g ; e ) ] .
+$$
+
+# 4 Experiments
+
+In this section, we first conduct experiments on a large quantum chemistry benchmark QM9, which is challenging for most baselines. Then we evaluate EIGNN on several useful molecule benchmarks and use attribution analysis to show that EIGNN increases the impact of edges and captures domain knowledge without human interference. Finally, we adopt our method to large-scale knowledge graphs and evaluate the performance on challenging relation prediction tasks using a wide variety of real-world datasets. All experimental results demonstrate a clear and substantial improvement of EIGNN over the state-of-the-art methods.
+
+# 4.1 Quantum Chemistry
+
+QM9 (Ramakrishnan et al., 2014) is a large benchmark containing 134k molecules with 12 quantum chemistry regression properties, which have been show to be quite challenging for many GNNs (Gilmer et al., 2017). Feature engineering of nodes and edges exactly follows (Gilmer et al., 2017) such that molecules are preprocessed as graphs according to atom features and bond features. We compare our EIGNN with nine state-of-the-art baselines which can be categorized into three groups according to the ability of handling edge features: i) GCN, ChebyNet, GAT and GIN (Xu et al., 2019) which simply use binary edge features to indicate the existence of a bond without any other edge features; ii) RGCN, GGNN, LNet and simplified MPNN (sMPNN) which consider bond types (no bond, single, double, triple, or aromatic); iii) MPNN and our EIGNN which use edge feature vectors to indicate both edge types and pairwise distance between atoms.
+
+For a fair comparison, we repeat all experiments 3 times with different random seeds while during each run, all methods share the same random seed. We randomly choose 10k molecules for validation, 10k molecules for testing, and keep the rest for training. Each target property is normalized to zero mean and unit variance for training. Each model is trained to predict the 12 target properties simultaneously. $\lambda$ is naively set to 1 for EIGNN. We use mean square error (MSE) loss to train the models for at most 300 epochs till convergence, and the performance is measured by mean absolute error (MAE). For LNet and GGNN, implementation of the readout function follows the original paper. While for all other models, we use the same set2set (Vinyals et al., 2015) readout, which has been demonstrated to work well in (Gilmer et al., 2017).
+
+Table 1: Quantum property regressions for 12 targets and overall performance (top two raws) on QM9. We repeat all experiments 3 times with different random seeds and report the average performance. Full results with standard deviation are presented in Appendix A, e.g., for MPNN and EIGNN, we have Avg. nMAE $0 . 0 3 9 8 \pm 0 . 0 0 0 2$ and 0.0357 ± 0.0005.   
+
+<table><tr><td>Method</td><td>GCN</td><td>ChebyNet</td><td>GAT</td><td>GIN</td><td>RGCN</td><td>GGNN</td><td>LNet</td><td>sMPNN</td><td>MPNN</td><td>EIGNN</td></tr><tr><td>Avg.nMAE</td><td>0.135</td><td>0.121</td><td>0.137</td><td>0.100</td><td>0.102</td><td>0.099</td><td>0.099</td><td>0.089</td><td>0.040</td><td>0.036</td></tr><tr><td>Avg.MAE</td><td>5.306</td><td>4.303</td><td>5.470</td><td>3.480</td><td>3.817</td><td>3.661</td><td>3.653</td><td>3.161</td><td>0.693</td><td>0.633</td></tr><tr><td>mu</td><td>0.568</td><td>0.518</td><td>0.567</td><td>0.478</td><td>0.506</td><td>0.518</td><td>0.472</td><td>0.472</td><td>0.110</td><td>0.097</td></tr><tr><td>alpha</td><td>0.881</td><td>0.793</td><td>0.891</td><td>0.621</td><td>0.632</td><td>0.608</td><td>0.623</td><td>0.528</td><td>0.332</td><td>0.294</td></tr><tr><td>HOMO(10-3)</td><td>5.451</td><td>4.775</td><td>5.429</td><td>4.183</td><td>4.453</td><td>4.483</td><td>3.889</td><td>3.854</td><td>2.481</td><td>2.230</td></tr><tr><td>LUMO(10-3)</td><td>6.400</td><td>5.674</td><td>6.331</td><td>4.796</td><td>5.138</td><td>5.153</td><td>4.194</td><td>4.549</td><td>2.862</td><td>2.593</td></tr><tr><td>gap(10-3)</td><td>8.201</td><td>7.097</td><td>8.193</td><td>6.096</td><td>6.500</td><td>6.602</td><td>5.813</td><td>5.634</td><td>3.620</td><td>3.275</td></tr><tr><td>R2</td><td>53.56</td><td>41.95</td><td>54.52</td><td>34.65</td><td>40.10</td><td>39.68</td><td>35.27</td><td>33.49</td><td>6.064</td><td>5.646</td></tr><tr><td>ZPVE(10-3)</td><td>2.533</td><td>2.527</td><td>2.271</td><td>1.744</td><td>1.477</td><td>1.292</td><td>1.438</td><td>1.345</td><td>0.679</td><td>0.612</td></tr><tr><td>UO</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.697</td><td>1.806</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>U</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.697</td><td>1.755</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>H</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.697</td><td>1.796</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>G</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.696</td><td>1.778</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>Cv</td><td>0.473</td><td>0.420</td><td>0.479</td><td>0.309</td><td>0.317</td><td>0.315</td><td>0.312</td><td>0.262</td><td>0.134</td><td>0.121</td></tr></table>
+
+![](images/b51754269df1a1a81766b31ec23b13e16833a1c14fe21641771ca4dfac60a05d.jpg)  
+Figure 1: Ablation study. Training and validation error on QM9. The shadow area indicates $m e a n \pm s t d$ over 3 runs.
+
+In Table 1, we list regression results for all methods. We report individual MAE for each target in their original scale, averaged MAE (Avg. MAE) over 12 properties, and averaged normalized MAE (Avg. nMAE; averaged over normalized target properties since different targets have different units and ranges). Our EIGNN achieves the best performance for each metric and each target. Now we are ready to answer the following research questions. i) Are edge features important? Yes. The error has a trend of decreasing with increasing edge features. The comparison between sMPNN (using edge types) and MPNN (using edge types and distance) directly verifies the importance of edge features. It is also consistent with the expert knowledge that distances between pairwise atoms are closely related to quantum properties. For example, the smaller the distance between the two atoms, the stronger the bond is, and consequently a higher bond energy is associated with this atom pair. ii) Does the EIGNN work? Yes. EIGNN achieves the best performance on each target, outperforming the strong baseline MPNN. Moreover, the advantage of EIGNN over MPNN is consistent over 3 runs and the standard deviation on this task is quite small. Detailed results are shown in Table 4 of Appendix A. iii) How does the EIGNN work? Our MI objective is easily implemented on top of vanilla loss function. We have shown that our objective enables preserving of edge information. Fig. 1 demonstrates that regularization such as $L _ { 2 }$ weight decay can increase training error while our objective does not. Moreover, the validation performance verifies that regularization itself does not reduce the validation error. Thus, the effectiveness of EIGNN is due to exploiting edge features rather than the regularization effect. We further run an ablation study where we concatenate edge features to node representations (i.e., MPNN+concat in Fig. 1) in message passing. Concatenation is unable to identify correlations between edges and nodes (Gilmer et al., 2017) and our results show that it slightly reduces the mean validation error but increases the variance.
+
+# 4.2 More Molecule Benchmarks with Potential Applications
+
+We further evaluate EIGNN on three molecule benchmarks: Lipophilicity (Wu et al., 2018), ESOL (Delaney, 2004) and FreeSolv (Mobley & Guthrie, 2014). These datasets contain fewer molecules, and have potential usages in applications such as chemistry, drug discovery, and materials science. For example, the property lipophilicity is an important feature of drug molecules that affects both membrane permeability and solubility. The dataset Lipophilicity contains 4200 compounds. ESOL provides water solubility data for 1128 compounds. FreeSolv contains hydration free energy of 642 small molecules in water. We conduct graph regression experiments on these benchmarks. All datasets are split into training, validation and test according to a proportion of 0.8/0.1/0.1. MPNN and our EIGNN share the same architecture with 3 layers of message passing and 3 steps of set2set. We repeat each experiment 3 times with different random seeds. Results of testing root mean square error (RMSE) in Table 2 verify the effectiveness of our method. Our EIGNN outperforms MPNN on each dataset and each run. Detailed results for each run are presented in Appendix B.
+
+Table 2: Testing RMSE on Lipophilicity, ESOL and FreeSolv.   
+
+<table><tr><td>Dataset</td><td colspan="2">Lipophilicity</td><td colspan="2">ESOL</td><td colspan="2">FreeSolv</td></tr><tr><td>Method</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td></tr><tr><td>mean±std</td><td>0.678±0.042</td><td>0.653±0.025</td><td>0.805±0.064</td><td>0.776±0.071</td><td>1.398±0.081</td><td>1.273±0.137</td></tr></table>
+
+![](images/93a30757aa01764b32a397063bc6a0e3a215232f566f99e62524e437f83f0e93.jpg)  
+Figure 2: Attribution analysis. The color indicates the impact of an edge/atom on the output, i.e., the regression result. EIGNN i) increases the edge attribution, ii) reduces the prediction error and iii) can learn domain knowledge without human interference.
+
+Attribution analysis. To understand how our EIGNN reduces the regression error, we conduct attribution analysis, i.e., attributing the prediction of a deep network to its input features, which usually builds up on the standard gradient operator (Sundararajan et al., features 2017). For an output $e$ as $\begin{array} { r } { S _ { e } = | \frac { \partial y } { \partial e } | } \end{array}$ $y$ , i.e., the prediction of a GNN, we define its sensitivity to an edge with , where $\left. \cdot \right.$ denotes the $L _ { 1 }$ norm. Similarly, the sensitivity to an atom with features $x$ is $\begin{array} { r } { S _ { x } = | \frac { \partial y } { \partial x } | } \end{array}$ . Then $S _ { e }$ and $S _ { x }$ are used as the metrics of attribution in our experiments. As an example, we show in Fig. 2 the attribution for two molecules in Lipophilicity: (a) $N c I n o n c I C ( = N O ) N c \mathcal { Q } c c c ( F ) c ( C l ) c \mathcal { Q }$ and (b) Oc1c2ncc3ccccc3c2nn1c4ccccc4 . Molecule in (a) has the potential to be used to treat, prevent and/or diagnose cancer Prinz et al. (2019). Compared with MPNN, we can observe an increasing of overall edge attribution under our EIGNN and a decreasing of prediction error in both cases. Interestingly, the attribution under EIGNN is similar to the expert knowledge of chemists: halogen atoms such as {Cl, Br, I} and their bond with the carbon atom greatly effect the lipophilicity of a molecule Wilcken et al. (2013), while atoms {O, N} also have high impact on the lipophilicity but usually in a negative way (Augustijns & Brewster, 2007). In Fig. 2 (a), the attribution of the halogen bond C-Cl and the pair {O, N} under our EIGNN is much higher than the one under MPNN, which is consistent with the expert knowledge. In Fig. 2 (b), similarly, the attribution of atoms {O, N} and the bond C-O under EIGNN is much higher. More examples are presented in Appendix C.
+
+# 4.3 Predicting Relations in Knowledge Graphs
+
+In this subsection, we adopt EIGNN to tackle the problem of relation prediction in knowledge graphs (KGs), which entails predicting whether a given triple is valid or not. For example, a triple (London, capital of, United Kingdom) should be classified as valid or London should be predicted as the capital of United Kingdom. KGs represent human knowledge as a directed graph, and have been widely used in practical applications, such as semantic search, dialogue generation, question answering etc. Recovering missing relations in KGs have been a major task for practical usages of KGs. We evaluate our methods on three benchmark datasets, WN18RR (Dettmers et al., 2018), FB15k-237 (Toutanova et al., 2015) and NELL-995 (Xiong et al., 2017). Without the reversible relation problem (Dettmers et al., 2018), WN18RR includes 11 relations scraped from WordNet for 40, 943 synsets. FB15k-237 is a subset of Freebase, and contains 14, 541 entities associated with 237 types of edge. NELL-995 is constructed from the $9 9 5 ^ { t h }$ iteration of NELL system, containing 75, 492 entities and 200 types of edge.
+
+Table 3: Experimental results on WN18RR, FB15K-237 and NELL-995 test sets. Hits@N values are in percentage. The best score is in bold and second best score is underlined.   
+
+<table><tr><td rowspan="3">Dataset</td><td colspan="4">WN18RR</td><td colspan="4">FB15K-237</td><td colspan="4">NELL-995</td></tr><tr><td colspan="4"></td><td rowspan="2">MRR</td><td colspan="3">Hit@N%</td><td rowspan="2">MRR</td><td colspan="3">Hit@N %</td></tr><tr><td>MRR</td><td>@1</td><td>@3</td><td>@10</td><td>@1</td><td>@3</td><td>@10</td><td>@1</td><td>@3</td><td>@10</td></tr><tr><td>DistMult</td><td>0.444</td><td>41.2</td><td>47</td><td>50.4</td><td>0.281</td><td>19.9</td><td>30.1</td><td>44.6</td><td>0.485</td><td>40.1</td><td>52.4</td><td>61</td></tr><tr><td>ComplEx</td><td>0.449</td><td>40.9</td><td>46.9</td><td>53</td><td>0.278</td><td>19.4</td><td>29.7</td><td>45</td><td>0.482</td><td>39.9</td><td>52.8</td><td>60.6</td></tr><tr><td>ConvE</td><td>0.456</td><td>41.9</td><td>47</td><td>53.1</td><td>0.312</td><td>22.5</td><td>34.1</td><td>49.7</td><td>0.491</td><td>40.3</td><td>53.1</td><td>61.3</td></tr><tr><td>TransE</td><td>0.243</td><td>42.7</td><td>44.1</td><td>53.2</td><td>0.279</td><td>19.8</td><td>37.6</td><td>44.1</td><td>0.401</td><td>34.4</td><td>47.2</td><td>50.1</td></tr><tr><td>ConvKB</td><td>0.265</td><td>58.2</td><td>44.5</td><td>55.8</td><td>0.289</td><td>19.8</td><td>32.4</td><td>47.1</td><td>0.43</td><td>37.0</td><td>47</td><td>54.5</td></tr><tr><td>R-GCN</td><td>0.123</td><td>8</td><td>13.7</td><td>20.7</td><td>0.164</td><td>10</td><td>18.1</td><td>30</td><td>0.12</td><td>8.2</td><td>12.6</td><td>18.8</td></tr><tr><td>KBGAT</td><td>0.436</td><td>35.8</td><td>48.1</td><td>57.8</td><td>0.431</td><td>36.1</td><td>45.8</td><td>56.9</td><td>0.514</td><td>42.9</td><td>55.3</td><td>67.8</td></tr><tr><td>EIGNN</td><td>0.438</td><td>35.7</td><td>48.8</td><td>58.1</td><td>0.451</td><td>37.4</td><td>48.2</td><td>60.5</td><td>0.523</td><td>43.8</td><td>56.1</td><td>68.3</td></tr></table>
+
+A critical issue of applying Eq. (3) to KGs is that high-dimensional embedding vectors are required to distinguish massive amount of entities and relations, leading to a rapid growth in number of parameters in EIGNN. To address this issue, we adopt the architecture of (Nathani et al., 2019) and learn graph attention based embeddings that target relation prediction on KGs as follows,
+
+$$
+\begin{array} { r } { m _ { v w } = f \big ( h _ { v } ^ { ( l ) } , e _ { v w } ^ { l } , h _ { w } ^ { ( l ) } \big ) , \alpha _ { v w } ^ { l } = \mathrm { s o f t m a x } \big ( a ^ { l } m _ { v w } ^ { l } \big ) , h _ { v } ^ { ( l + 1 ) } = \sigma \left( \sum _ { w \in \mathcal { N } _ { v } } \alpha _ { v w } ^ { l } m _ { v w } ^ { l } \right) . } \end{array}
+$$
+
+Compared with Eq. (3), where $m _ { v w } = f ( e _ { v w } ) h _ { w }$ , the above equation absorbs the transform matrix $f ( e _ { v w } )$ into $f ( h _ { v } ^ { ( l ) } , e _ { v w } , h _ { w } ^ { ( l ) } )$ and reduces the model parameters. In the following experiments, we implement $f$ using a MLP as in previous experiments, and maximizes the MI between $e _ { v w }$ and $m _ { v w }$ by introducing another MLP with $\lambda = 0 . 0 1$ . Multi-head attention is further introduced to stabilize the learning process and encapsulate more information about neighbors according to (Veličković et al., 2018). After training EIGNN, ConvKB (Nguyen et al., 2018) is adopted as a regression function for a given triple by analyzing the global embedding properties across each dimension.
+
+In the relation prediction task, the aim is to predict a triple $( v , e _ { v w } , w )$ with $\boldsymbol { v }$ or $w$ missing. We can generate a set of candidate triples for each missing entity $v$ by randomly replacing it with an arbitrary one. Scores can be calculated by ConvKB for all triples, and we find the rank of a correct triple by sorting all scores in ascending order. Thus, the performance of relation prediction task can be evaluated by mean reciprocal rank (MRR) and the proportion of correct entities in the top $N$ ranks (Hits@N) for $N = 1 , 3$ , and 10 (Bordes et al., 2013). We compare our EIGNN with seven state-of-the-art baselines focusing on this task: DistMult (Yang et al., 2014), ComplEx (Trouillon et al., 2016), ConvE (Dettmers et al., 2018), TransE (Bordes et al., 2013), ConvKB (Nguyen et al., 2018), RGCN (Schlichtkrull et al., 2018) and KBGAT (Nathani et al., 2019). As shown in Table 3, our EIGNN achieves the best performance for each metric on FB15K-237 and NELL-995, and achieves the best performance on WN18RR with Hit $^ \mathrm { ( a 3 }$ and 10 metrics. The results of KBGAT are reproduced following the official implementation1, and the results of other methods can be found in the previous peer-reviewed publications, i.e. (Nathani et al., 2019).
+
+# 5 Conclusions
+
+In this work, to make better use of edge features in GNNs, we proposed the edge information maximized graph neural network (EIGNN) that maximizes the mutual information between edge feature vectors and message passing channels. We reformulated the mutual information as a differentiable objective by adopting a variational approach. We have theoretically proved that our proposed objective enables EIGNN to preserve edge information and empirically evaluated EIGNN’s performance on a variety of benchmarks incorporating an array of challenging molecular datasets and knowledge graphs. These results clearly manifested a substantial improvement of EIGNN over the prior state-of-the-art methods. Apart from demonstrating the impressive performance of EIGNN, we also showed that its effectiveness is due to exploitation of edge features instead of the regularization effect. Notably, attribution analysis on molecular graphs show that EIGNN can capture domain knowledge in an end-to-end fashion.
+
+# References
+
+David Barber Felix Agakov. The im algorithm: a variational approach to information maximization. NeurIPS, 2004.
+
+Patrick Augustijns and Marcus E Brewster. Solvent systems and their selection in pharmaceutics and biopharmaceutics, volume 190. Springer, 2007.
+
+David Barber and Felix V Agakov. Kernelized infomax clustering. In NeurIPS, 2006.
+
+Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In NeurIPS, pp. 2787–2795, 2013.
+
+John S Bridle, Anthony JR Heading, and David JC MacKay. Unsupervised classifiers, mutual information and’phantom targets. In NeurIPS, 1992.
+
+Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: interpretable representation learning by information maximizing generative adversarial nets. In NeurIPS, 2016.
+
+Kyunghyun Cho, Bart Van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.
+
+Michaël Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on graphs with fast localized spectral filtering. In NeurIPS, 2016.
+
+John S Delaney. Esol: estimating aqueous solubility directly from molecular structure. Journal of chemical information and computer sciences, 44(3):1000–1005, 2004.
+
+Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel. Convolutional 2d knowledge graph embeddings. In AAAI, 2018.
+
+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 NeurIPS, 2015.
+
+Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ICML, 2017.
+
+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 NeurIPS, pp. 1024–1034, 2017.
+
+R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. 2019.
+
+Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Pre-training graph neural networks. arXiv preprint arXiv:1905.12265, 2019.
+
+Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017.
+
+Andreas Krause, Pietro Perona, and Ryan G Gomes. Discriminative clustering by regularized information maximization. In NeurIPS, 2010.
+
+Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In ICLR, 2016.
+
+Renjie Liao, Zhizhen Zhao, Raquel Urtasun, and Richard S Zemel. Lanczosnet: Multi-scale deep graph convolutional networks. In ICLR, 2019.
+
+Ralph Linsker. Self-organization in a perceptual network. Computer, 21(3):105–117, 1988.
+
+David L Mobley and J Peter Guthrie. Freesolv: a database of experimental and calculated hydration free energies, with input files. Journal of computer-aided molecular design, 28 (7):711–720, 2014.
+
+Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In AAAI, volume 33, pp. 4602–4609, 2019.
+
+Deepak Nathani, Jatin Chauhan, Charu Sharma, and Manohar Kaul. Learning attentionbased embeddings for relation prediction in knowledge graphs. The 57th Annual Meeting of the Association for Computational Linguistics (ACL), 2019.
+
+Dai Quoc Nguyen, Tu Dinh Nguyen, Dat Quoc Nguyen, and Dinh Phung. A novel embedding model for knowledge base completion based on convolutional neural network. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 2 (Short Papers), pp. 327–333, 2018.
+
+Bianka Prinz, Jerry M Thomas, Ansgar Brock, Viviana Cremasco, Catherine Anne SabatosPeyton, Glenn Dranoff, Scott Chapel, Andrew Lake, Alison Paterson, Rachel W O’connor, et al. Antibody molecules to cd73 and uses thereof, January 31 2019. US Patent App. 16/014,744.
+
+Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1: 140022, 2014.
+
+Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1): 61–80, 2009.
+
+Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In European Semantic Web Conference, pp. 593–607. Springer, 2018.
+
+Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In ICML, pp. 3319–3328. JMLR. org, 2017.
+
+Kristina Toutanova, Danqi Chen, Patrick Pantel, Hoifung Poon, Pallavi Choudhury, and Michael Gamon. Representing text for joint embedding of text and knowledge bases. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1499–1509, 2015.
+
+Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. Complex embeddings for simple link prediction. In ICML, pp. 2071–2080, 2016.
+
+Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. In ICLR, 2018.
+
+Petar Veličković, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. In ICLR, 2019.
+
+Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015.
+
+Rainer Wilcken, Markus O Zimmermann, Andreas Lange, Andreas C Joerger, and Frank M Boeckler. Principles and applications of halogen bonding in medicinal chemistry and chemical biology. Journal of medicinal chemistry, 56(4):1363–1388, 2013.
+
+Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine learning. Chemical science, 9(2):513–530, 2018.   
+Wenhan Xiong, Thien Hoang, and William Yang Wang. Deeppath: A reinforcement learning method for knowledge graph reasoning. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 564–573, 2017.   
+Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019.   
+Bishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Embedding entities and relations for learning and inference in knowledge bases. ICLR, 2014.   
+Zhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, Will Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. In NeurIPS, pp. 4800–4810, 2018.   
+Jie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph neural networks: A review of methods and applications. arXiv preprint arXiv:1812.08434, 2018.
+
+# A Full Results on QM9
+
+Table 4: Full results of quantum property regressions for 12 targets and overall performance (nMAE and MAE in top two raws) on QM9. We repeat all experiments 3 times with different random seeds and report the average performance and standard deviation. This is a supplement for Table 1. in the main text.   
+
+<table><tr><td>Method</td><td>GCN</td><td>ChebyNet</td><td>GAT</td><td>GIN</td></tr><tr><td>Avg.nMAE</td><td>0.1350±0.0046</td><td>0.1206±0.0084</td><td>0.1367±0.0050</td><td>0.1001±0.0007</td></tr><tr><td>Avg.MAE</td><td>5.3063±0.1964</td><td>4.3032±0.4814</td><td>5.4698±0.2040</td><td>3.4799±0.0402</td></tr><tr><td>mu</td><td>0.5679±0.0078</td><td>0.5180±0.0131</td><td>0.5670±0.0102</td><td>0.4783±0.0041</td></tr><tr><td>alpha</td><td>0.8811±0.0308</td><td>0.7932±0.0778</td><td>0.8913±0.0314</td><td>0.6209±0.0028</td></tr><tr><td>HOMO(10-3)</td><td>5.4510±0.0790</td><td>4.7750±0.2040</td><td>5.4290±0.1660</td><td>4.1830±0.0370</td></tr><tr><td>LUMO(10-3)</td><td>6.4000±0.1230</td><td>5.6740±0.2670</td><td>6.3310±0.2390</td><td>4.7960±0.0520</td></tr><tr><td>gap(10-3)</td><td>8.2010±0.2150</td><td>7.0970±0.3620</td><td>8.1930±0.2910</td><td>6.0960±0.0420</td></tr><tr><td>R2</td><td>53.563±1.0319</td><td>41.950±4.8289</td><td>54.519±1.5992</td><td>34.647±0.2167</td></tr><tr><td>ZPVE(10-3)</td><td>2.5330±0.1070</td><td>2.5270±0.3560</td><td>2.2710±0.1450</td><td>1.7440±0.0100</td></tr><tr><td>UO</td><td>2.0422±0.3281</td><td>1.9842±0.2035</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>U</td><td>2.0422±0.3281</td><td>1.9842±0.2035</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>H</td><td>2.0422±0.3281</td><td>1.9842±0.2035</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>G</td><td>2.0423±0.3281</td><td>1.9842±0.2036</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>Cv</td><td>0.4730±0.0209</td><td>0.4199±0.0499</td><td>0.4787±0.0164</td><td>0.3093±0.0035</td></tr><tr><td>Method</td><td>RGCN</td><td>GGNN</td><td>LNet</td><td>sMPNN</td></tr><tr><td>Avg.nMAE</td><td>0.1021±0.0016</td><td>0.0992±0.0013</td><td>0.0992±0.0061</td><td>0.0888±0.0014</td></tr><tr><td>Avg.MAE</td><td>3.8175±0.0605</td><td>3.6608±0.0723</td><td>3.6527±0.3417</td><td>3.1610±0.0697</td></tr><tr><td>mu</td><td>0.5056±0.0048</td><td>0.5179±0.0076</td><td>0.4717±0.0063</td><td>0.4718±0.0096</td></tr><tr><td>alpha</td><td>0.6321±0.0145</td><td>0.6077±0.0092</td><td>0.6225±0.0508</td><td>0.5278±0.0106</td></tr><tr><td>HOMO(10-3)</td><td>4.4530±0.1290</td><td>4.4830±0.0650</td><td>3.8889±0.1617</td><td>3.8540±0.0410</td></tr><tr><td>LUMO(10-3)</td><td>5.1380±0.1210</td><td>5.1530±0.0890</td><td>4.1935±0.2205</td><td>4.5490±0.0810</td></tr><tr><td>gap(10-3)</td><td>6.5000±0.1390</td><td>6.6020±0.1400</td><td>5.8132±0.6456</td><td>5.6340±0.0570</td></tr><tr><td>R2</td><td>40.102±0.7428</td><td>39.685±0.8212</td><td>35.275±3.0531</td><td>33.489±0.6562</td></tr><tr><td>ZPVE(10-3)</td><td>1.4770±0.0090</td><td>1.2920±0.0340</td><td>1.4376±0.0769</td><td>1.3450±0.0260</td></tr><tr><td>UO</td><td>1.0589±0.0231</td><td>0.6969±0.0413</td><td>1.8058±0.2533</td><td>0.7914±0.0446</td></tr><tr><td>U</td><td>1.0589±0.0231</td><td>0.6966±0.0418</td><td>1.7555±0.2196</td><td>0.7914±0.0446</td></tr><tr><td>H</td><td>1.0589±0.0231</td><td>0.6974±0.0408</td><td>1.7964±0.2428</td><td>0.7914±0.0446</td></tr><tr><td>G</td><td>1.0589±0.0231</td><td>0.6961±0.0421</td><td>1.7780±0.2458</td><td>0.7914±0.0446</td></tr><tr><td>Cv</td><td>0.3170±0.0152</td><td>0.3146±0.0125</td><td>0.3124±0.0303</td><td>0.2625±0.0040</td></tr><tr><td>Method</td><td>MPNN</td><td>EIGNN</td><td></td><td></td></tr><tr><td>Avg.nMAE</td><td>0.0398±0.0002</td><td>0.0357±0.0005</td><td></td><td></td></tr><tr><td>Avg.MAE</td><td>0.6929±0.0212</td><td>0.6331±0.0298</td><td></td><td></td></tr><tr><td>mu</td><td>0.1095±0.0014</td><td>0.0974±0.0026</td><td></td><td></td></tr><tr><td>alpha</td><td>0.3318±0.0026</td><td>0.2939±0.0054</td><td></td><td></td></tr><tr><td>HOMO(10-3)</td><td>2.4810±0.0200</td><td>2.2300±0.0310</td><td></td><td></td></tr><tr><td>LUMO(10-3)</td><td>2.8620±0.0370</td><td>2.5930±0.0440</td><td></td><td></td></tr><tr><td>gap(10-3)</td><td>3.6200±0.0180</td><td>3.2750±0.0520</td><td></td><td></td></tr><tr><td>R2</td><td>6.0637±0.2511</td><td>5.6464±0.3098</td><td></td><td></td></tr><tr><td>ZPVE(10-3)</td><td>0.6790±0.0140</td><td>0.6120±0.0170</td><td></td><td></td></tr><tr><td>UO</td><td>0.4164±0.0225</td><td>0.3574±0.0100</td><td></td><td></td></tr><tr><td>U</td><td>0.4164±0.0225</td><td>0.3575±0.0100</td><td></td><td></td></tr><tr><td>H</td><td>0.4164±0.0225</td><td>0.3574±0.0100</td><td></td><td></td></tr><tr><td>G</td><td>0.4164±0.0225</td><td>0.3575±0.0101</td><td></td><td></td></tr><tr><td>Cv</td><td>0.1339±0.0013</td><td>0.1208±0.0027</td><td></td><td></td></tr></table>
+
+We present full results of quantum property regressions on QM9 with average performance and standard deviation in Table 4. The $( 1 0 ^ { - 3 }$ ) in the parentheses indicates that the values in the corresponding raw of the table should multiply by $1 0 ^ { - 3 }$ . This is simply for clear presentation of the values. We also present a detailed descriptions on the target properties in Table 5 for your reference.
+
+In our results, we directly report MAE instead of Error Ratio [(MAE)/(Chemical Accuracy) (Gilmer et al., 2017)], because it is common to report MAE in terms of chemical unit. This practice has been widely adopted not only in computational chemistry but also in the machine learning community working on molecular graphs (Wu et al., 2018; Morris et al., 2019). Still, we add Table 6 which contains the Error Ratio for MPNN and our EIGNN. In this comparison, we follow (Gilmer et al., 2017) and train models separately to predict each target. Our EIGNN consistently outperforms MPNN.
+
+Table 5: Regression targets on QM9.   
+
+<table><tr><td>Target property</td><td>Description</td><td>Unit</td></tr><tr><td>mu</td><td>Dipole moment</td><td>D</td></tr><tr><td>alpha</td><td>Isotropic polarizability</td><td>a</td></tr><tr><td>HOMO</td><td>Highest occupied molecular orbital energy</td><td>Eh</td></tr><tr><td>LUMO</td><td>Lowest unoccupied molecular orbital energy</td><td>Eh</td></tr><tr><td>gap</td><td>Gap between HOMO and LUMO</td><td>Eh</td></tr><tr><td>R2</td><td>Electronic spatial extent</td><td>品</td></tr><tr><td>ZPVE</td><td>Zero point vibrational energy</td><td>Eh</td></tr><tr><td>UO</td><td>Internal energy at OK</td><td>Eh</td></tr><tr><td>U</td><td>Internal energy at 298.15K</td><td>Eh</td></tr><tr><td>H</td><td>Enthalpy at 298.15K</td><td>Eh</td></tr><tr><td>G</td><td>Free energy at 298.15K</td><td>Eh</td></tr><tr><td>Cv</td><td>Heat capavity at 298.15K</td><td>cal molK</td></tr></table>
+
+Table 6: Error Ratio [(MAE)/(Chemical Accuracy) (Gilmer et al., 2017)] on QM9. Note that the energy values of $\{ \mathrm { U 0 , ~ U , ~ H , ~ G } \}$ are per molecule rather than per atom. Following (Gilmer et al., 2017), models are separately trained on each target.   
+
+<table><tr><td>Target</td><td>MPNN</td><td>EIGNN</td><td>Improvement (%)</td></tr><tr><td>mu</td><td>0.87</td><td>0.80</td><td>8.24</td></tr><tr><td>alpha</td><td>2.64</td><td>2.44</td><td>7.57</td></tr><tr><td>HOMO</td><td>1.54</td><td>1.39</td><td>10.2</td></tr><tr><td>LUMO</td><td>1.31</td><td>1.28</td><td>2.13</td></tr><tr><td>gap</td><td>2.20</td><td>1.97</td><td>10.4</td></tr><tr><td>R2</td><td>1.00</td><td>0.72</td><td>28.4</td></tr><tr><td>ZPVE</td><td>5.31</td><td>4.43</td><td>16.5</td></tr><tr><td>UO</td><td>64.3</td><td>35.8</td><td>44.4</td></tr><tr><td>U</td><td>56.6</td><td>23.6</td><td>58.3</td></tr><tr><td>H</td><td>77.4</td><td>35.2</td><td>54.5</td></tr><tr><td>G</td><td>46.6</td><td>34.4</td><td>26.1</td></tr><tr><td>Cv</td><td>1.69</td><td>1.79</td><td>-6.22</td></tr></table>
+
+B Full Results on Lipophilicity, ESOL and FreeSolv
+
+In this section, we present experimental results on Lipophilicity, ESOL and FreeSolv with detailed results for each run. The results in Table 7 verify that our EIGNN consistently outperforms MPNN.
+
+# C More Examples of Attribution
+
+In this section, we present more examples of attribution analysis on Lipophilicity. As a supplement for Fig. 2 in the main text, the observation here is similar. Compared with MPNN, we can observe an increasing of overall edge attribution under our EIGNN and a decreasing of prediction error in both cases. Notably, our EIGNN is able to capture the expert knowledge. (a) The molecule is $C N [ C @ \mathbb { Q } H ] ( C ) C ( = O ) N [ C @ \mathbb { Q } H ] ( C 1 C C C C T 1 ) C ( =$ $O ) N [ C @ H ] 2 C C C N ( C C c ( F ) c c 3 ) C 2$ . The attribution of $\{ \mathrm { O } , \mathrm { N } \}$ and the halogen atom $\mathrm { F }$ is higher under EIGNN. (b) The molecule is $C C ( C ) N 1 C C N [ C @ H ] ( C 1 ) C ( =$ $O ) N 2 C C N ( C C 2 ) C ( = O ) N c 3 c c c ( C l ) c ( C l ) c 3$ . Our EIGNN successfully captures the importance of two critical halogen atoms Cl and several atoms N. (c) The molecule is $C O c 1 c c ( c c 1 ) C ( = \ O ) N 2 C C C C 2 \ = \ O$ . The attribution of two atoms $\mathrm { \ o }$ at the top is
+
+Table 7: Testing RMSE on Lipophilicity, ESOL and FreeSolv. This is a supplement for Table 2 in the main text.   
+
+<table><tr><td>Dataset</td><td colspan="2">Lipophilicity</td><td colspan="2">ESOL</td><td colspan="2">FreeSolv</td></tr><tr><td>Seed</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td></tr><tr><td>0</td><td>0.718</td><td>0.676</td><td>0.770</td><td>0.718</td><td>1.396</td><td>1.109</td></tr><tr><td>1</td><td>0.696</td><td>0.664</td><td>0.750</td><td>0.733</td><td>1.299</td><td>1.265</td></tr><tr><td>2</td><td>0.620</td><td>0.619</td><td>0.894</td><td>0.876</td><td>1.499</td><td>1.443</td></tr><tr><td>mean±std</td><td>0.678±0.042</td><td>0.653±0.025</td><td>0.805±0.064</td><td>0.776±0.071</td><td>1.398±0.081</td><td>1.273±0.137</td></tr></table>
+
+much higher under EIGNN. (d) The molecule is $C c 1 c c 2 N C ( = O ) C ( = C C ( = O ) c 2 c c 1 C ) O$ .   
+The attribution of atoms O is much higher under EIGNN.
+
+![](images/d35b4c5026ccc9e9cd8864632869ef2ae4dd487409a61f9850c2293c8640530b.jpg)  
+Figure 3: More examples of attribution analysis. The color indicates the impact of an edge/atom on the output, i.e., the regression result. EIGNN i) increases the edge attribution, ii) reduces the prediction error and iii) can learn domain knowledge without human interference.

parse/train/BygZK2VYvB/BygZK2VYvB_content_list.json

@@ -0,0 +1,1581 @@
+[
+    {
+        "type": "text",
+        "text": "Utilizing Edge Features in Graph Neural Networks via Variational Information Maximization ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            826,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            195,
+            419,
+            223
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            260,
+            545,
+            275
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) broadly follow the scheme that the representation vector of each node is updated recursively using the message from neighbor nodes, where the message of a neighbor is usually pre-processed with a parameterized transform matrix. To make better use of edge features, we propose the Edge Information maximized Graph Neural Network (EIGNN) that maximizes the Mutual Information (MI) between edge features and message passing channels. The MI is reformulated as a differentiable objective via a variational approach. We theoretically show that the newly introduced objective enables the model to preserve edge information, and empirically corroborate the enhanced performance of MI-maximized models across a broad range of learning tasks including regression on molecular graphs and relation prediction in knowledge graphs. ",
+        "bbox": [
+            233,
+            291,
+            764,
+            459
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            339,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many real-world datasets naturally come in the form of graphs, such as citation networks (Kipf & Welling, 2017), social networks Hamilton et al. (2017), knowledge graphs (Schlichtkrull et al., 2018), molecular graphs (Scarselli et al., 2009; Duvenaud et al., 2015) etc., all of which consist of a number of nodes and edges equipped with their inherent features. Recently, impressive performance has been achieved in graph learning tasks with various forms of Graph Neural Networks (GNNs) (Zhou et al., 2018). Compared to prior works, such as node2vec (Grover & Leskovec, 2016), GNNs learn the state of a node by recursively aggregating messages from its neighbors: combining the graph structure with node features. Intuitively, edge features should play an important role in graph learning tasks. For example, chemical bonds in a molecule have a high impact on chemical properties of molecules, and edge features in knowledge graphs encode important relations between concepts, data, and entities. Our proposed method focuses on improving the usage of edge features in GNNs. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            686
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The expressive power of GNNs largely depends on how the message is passed between nodes. A widely adopted scheme is multiplying neighbor node states with a parameterized transform matrix before aggregation (Gilmer et al., 2017; Xu et al., 2019). Despite tremendous success of GNNs, existing models do not exhaustively exploit the full potentials of edge features on graphs. For example, many GNNs such as GCN (Kipf & Welling, 2017), ChebyNet (Defferrard et al., 2016) and GAT (Veličković et al., 2018) do not even consider categorized edge types. To utilize edge features in multi-relational graphs, RGCN (Schlichtkrull et al., 2018) proposes to learn a different transform matrix for each edge type, respectively. However, it does not generalize to edge features in continuous space. MPNN (Gilmer et al., 2017) introduces an edge network that takes edge feature vectors as input and outputs transform matrices, which are used to transform states of neighbor nodes. In principle, the MPNN framework can handle complex edge features. Yet, the lack of maximization of MI between edge and message channels implies that the MPNN may give an edge-independent transform matrix. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we aim to more efficiently exploit the full potentials of edge features from the perspective of training. We propose the Edge Information maximized Graph Neural Network (EIGNN) that maximizes the Mutual Information (MI) between edge features and the message passing channel which is parameterized as the transform matrix in the widely-accepted message passing framework (transformation and aggregation) (Gilmer et al., 2017; Xu et al., 2019). Considering the challenge of computing the MI, we adopt a variational approach to reformulate it as an differentiable objective, which can be easily applied as a regularization term. We theoretically show that EIGNN can reduce information loss of edge features. Apart from demonstrating the impressive performance of EIGNN on extensive benchmarks of molecular graphs and knowledge graphs, we also analyze and attribute the enhanced effectiveness of EIGNN to the exploitation of edge features instead of the regularization effects. Notably, attribution analysis on molecular graphs show that EIGNN can capture domain knowledge without human interference. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            243
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Preliminaries Let $G = ( \\nu , \\mathcal { E } )$ be a graph with node feature vectors $x _ { v } \\in \\mathbb { R } ^ { d }$ for node $v \\in \\nu$ and edge feature vectors $e _ { v w } \\in \\mathcal { E }$ for the edge connecting node $v$ and $w$ . In GNNs, the state of each node is updated recursively using neighbor nodes. Let $\\mathcal { N } _ { v }$ be the set of neighbor nodes of $v$ and $h _ { v } ^ { ( l ) } \\in \\mathbb { R } ^ { d _ { l } }$ be the hidden state of $v$ at $\\it l$ -th layer, where $d _ { l }$ is the dimension of the hidden layer. For simplicity of notation, we use a single $d$ to denote the dimension such that $h _ { v } ^ { ( l ) } \\in \\mathbb { R } ^ { d }$ . We also have $h _ { v } ^ { ( 0 ) } = x _ { v }$ at the input layer. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            347
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Related works ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            364,
+            357,
+            381
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 Relational Modeling in Graph Neural Networks ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            393,
+            630,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Single-relational modeling. Many variants such as GCN (Kipf & Welling, 2017), GAT (Veličković et al., 2018), ChebyNet (Defferrard et al., 2016), GraphSAGE (Hamilton et al., 2017) focus on learning node states. These models can assign weight to neighbors, but they can not handle various edge features. A typical neighborhood aggregation scheme is ",
+        "bbox": [
+            173,
+            420,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/897a3f0394352afdd981afc2c5beb5e43696de6f029404d486b83b2d43b34699.jpg",
+        "text": "$$\nh _ { v } ^ { ( l + 1 ) } = \\sigma \\left( \\sum _ { w \\in \\mathcal { N } _ { v } } \\alpha _ { v w } W _ { 1 } ^ { ( l ) } h _ { w } ^ { ( l ) } + W _ { 0 } ^ { ( l ) } h _ { v } ^ { ( l ) } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            334,
+            478,
+            663,
+            503
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\sigma$ denotes an activation function, $\\alpha _ { v w }$ can be a normalization constant or a learned attention coefficient (Veličković et al., 2018). States of all neighbors are multiplied by the same trainable transform matrix $W _ { 1 } ^ { ( l ) }$ . Sometimes the self-connection is also treated in the same way, s.t., W (l)0 = W (l)1 . ",
+        "bbox": [
+            174,
+            505,
+            825,
+            569
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Multi-relational modeling. A simple strategy to handle multi-relational graphs is assigning each edge type with a separate transform matrix as presented in RGCN (Schlichtkrull et al., 2018) and adopted by GGNN (Li et al., 2016) and LNet (Liao et al., 2019). RGCN updates node states according to the following scheme ",
+        "bbox": [
+            174,
+            582,
+            825,
+            637
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ed04d513db0882ec07a019e0ecc97ba5d85793352a6b0896db29b31bf4e31a2.jpg",
+        "text": "$$\n\\begin{array} { r } { h _ { v } ^ { ( l + 1 ) } = \\sigma \\left( \\sum _ { r \\in \\mathcal { R } } \\sum _ { w \\in \\mathcal { N } _ { v } ^ { r } } \\alpha _ { v w , r } W _ { r } ^ { ( l ) } h _ { w } ^ { ( l ) } + W _ { 0 } ^ { ( l ) } h _ { v } ^ { ( l ) } \\right) , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            638,
+            697,
+            672
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { N } _ { v } ^ { r }$ is the collection of neighboring nodes of $\\boldsymbol { v }$ with relation $r \\in \\mathcal { R }$ and $\\alpha _ { v w , r }$ is a normalization constant similar as $\\alpha _ { v w }$ in Eq. (1). Such a scheme faces challenge in handling edge features of continuous space. GGNN and LNet do not focus on the improvement of edge expressibility. GGNN introduces Gated Recurrent Unit (GRU) (Cho et al., 2014) and LNet focus on handling multi-scale connections. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Complex-relational modeling. The relation in a graph can be quite complex, expressed as a general feature vector $e$ . MPNN (Gilmer et al., 2017) introduces an edge network which takes edge feature vectors as input and outputs transform matrices. A single edge network is shared in a MPNN model. The forward propagation is formalized as ",
+        "bbox": [
+            174,
+            756,
+            823,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa5600ecca6e4db258cd8b03cebc33d5e5982081f6001312ac655c155dc4299d.jpg",
+        "text": "$$\nm _ { v } ^ { ( l + 1 ) } = \\sigma \\left( \\sum _ { w \\in \\mathcal { N } _ { v } } f ( e _ { v w } ) h _ { w } ^ { ( l ) } + W _ { 0 } ^ { ( l ) } h _ { v } ^ { ( l ) } \\right) , \\quad h _ { v } ^ { ( l + 1 ) } = \\mathrm { G R U } ( h _ { v } ^ { ( l ) } , m _ { v } ^ { ( l + 1 ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            813,
+            764,
+            839
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $f : e  W$ denotes the edge network. Recently, some research works treat a multirelational problem as the complex-relational one by introducing a continuous edge embedding vector for each edge type, so as to handle increasing number of relations (Nathani et al., 2019). Although the MPNN architecture allows the usage of arbitrary edge features, this advantage is not utilized in practice. MPNN can actually learn an edge-independent transform matrix. A GNN model that efficiently utilizes edge features is yet to emerge. ",
+        "bbox": [
+            173,
+            840,
+            826,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 Readout functions ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            377,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "After several forward propagations, GNNs yield final states of all nodes, which are suitable for node/edge classification or regression. For graph classification or regression tasks, we can apply a readout function (Ying et al., 2018; Vinyals et al., 2015) such that ",
+        "bbox": [
+            174,
+            128,
+            825,
+            171
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6b3aeb614b48bbadc542b9ff62623957cbe52cd0d89c9bf49da41a0802158ccd.jpg",
+        "text": "$$\ny = R ( \\{ h _ { v } ^ { L } | v \\in G \\} ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            175,
+            570,
+            193
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $h _ { v } ^ { L }$ is the state of $v$ at the last layer, $R$ is the readout function that outputs a graph-level representation $y$ , e.g., summing up the final node states, applying hierarchical pooling (Ying et al., 2018) or using the set2set model (Vinyals et al., 2015). ",
+        "bbox": [
+            174,
+            195,
+            825,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 Our method ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            256,
+            328,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 The Usage of Mutual Information ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            285,
+            508,
+            300
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In probability theory and information theory, MI is a measure of mutual dependence between two random variables. Our method proposes to preserve edge information in GNNs, which is important in many real-world graph structures such as molecules - apart from node (atom) features, attributes of edges (bonds) are equally important for predicting properties of molecules. To this end, we maximize $I ( e ; W )$ - the MI between the edge feature vector $e$ and the message passing channel, i.e., the transform matrix $W$ which is used to transform neighbor node states in the forward propagation. Our method can be easily generalized to directly maximize the MI between edge features and the message itself in methods that do not explicitly have the transform matrix, e.g., the message from node $w$ to node $v$ can be expressed as $f ( h _ { v } , e _ { v w } , h _ { w } )$ rather than $f ( e _ { v w } ) h _ { w }$ , which is shown in Section 4.3. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            452
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An general principle of maximum MI is described for unsupervised learning task by (Linsker, 1988) and MI inspired objective functions have long been adopted in unsupervised learning (Bridle et al., 1992; Barber & Agakov, 2006; Veličković et al., 2019; Hjelm et al., 2019), semi-supervised learning (Krause et al., 2010) and generative adversarial networks (Chen et al., 2016). Specifically, DGI (Veličković et al., 2019) also applies MI to GNNs. DGI proposes to learn node-wise representations in an unsupervised manner by maximizing the MI between node representations and corresponding high-level summaries of graphs, using adversarial learning and negative sampling. The node representations may then be retrieved and used for downstream tasks, such as node classification. DGI can be used to pre-train GNNs, as demonstrated in Hu et al. (2019). Our EIGNN also proposes information maximization but targets a completely different objective and adopts a quite different approach. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            611
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 A Variational Approach to Maximize Mutual Information ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            626,
+            704,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Computing $I ( e ; W )$ itself is intractable in practice, needless to say that training a model requires the derivative. Thus, we adopt a variational approach (Agakov, 2004) to reformulate $I ( e ; W )$ as a differentiable objective. We show that our objective is an approximated lower bound of $I ( e ; W )$ and notably, optimizing our objective does lead to maximizing $I ( e ; W )$ . Following MPNN (Gilmer et al., 2017), we use an edge network to parameterize the transform matrix $W$ and relate it to edge features. Therefore, the prior $p ( W | e )$ is ",
+        "bbox": [
+            174,
+            651,
+            825,
+            737
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/064575c5b1ecce9a7f7dbda9406409bc548a24e03885ab642abea6e3861b477f.jpg",
+        "text": "$$\np ( W | e ) = \\delta ( W - f ( e ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            739,
+            581,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\delta ( \\cdot )$ is the Dirac delta function. The posterior $p ( e | W )$ is intractable, so we define a variational distribution $q ( e | W )$ , which can be obtained by defining a neural network $g : W \\to e$ Specifically, $q ( e | W )$ substitutes to some distribution (such as Gaussian distribution) with parameter $g ( W )$ . In this way, $f$ and $g$ are similar to the probabilistic encoder and decoder in the Variational Auto-Encoder (VAE) (Kingma $\\&$ Welling, 2013). Then we can approximate $I ( e ; W )$ with a differentiable objective $L _ { I } ( f , g ; e )$ as follows. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            843
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Let e be the edge feature vector, $W$ be the transform matrix with conditional distribution $p ( W | e )$ specified by the probabilistic encoder $f$ as shown in Eq. (5) and $q ( e | W )$ be the variational distribution specified by the probabilistic decoder $g$ , then we have ",
+        "bbox": [
+            174,
+            844,
+            825,
+            886
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1ddb6427dd9ce6d7604222cb7abb1323181e83e653a98be12246cba2bb6046d8.jpg",
+        "text": "$$\nI ( e ; W ) \\geq H ( e ) + \\mathbb { E } _ { e \\sim p ( e ) } [ \\mathcal { L } _ { I } ( f , g ; e ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            890,
+            632,
+            906
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L } _ { I } ( f , g ; e ) = \\log q ( e | f ( e ) )$ and $H ( \\cdot )$ denotes the entropy. ",
+        "bbox": [
+            173,
+            909,
+            617,
+            925
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Proof. Let $D _ { K L } ( \\cdot \\parallel \\cdot )$ denote the KL-divergence, which should be nonnegative, then we have ",
+        "bbox": [
+            173,
+            102,
+            823,
+            119
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d1f9d2080ad50a36557e6e9a92ee313414557012e82f952539a8c31f6ce4b4bc.jpg",
+        "text": "$$\n\\begin{array} { r l } { I ( e ; W ) = H ( e ) - H ( e | W ) } & { } \\\\ { \\ } & { = H ( e ) + \\mathbb { E } _ { W \\sim p ( W ) } [ \\mathbb { E } _ { e \\sim p ( e | W ) } [ \\log p ( e | W ) ] ] } \\\\ { \\ } & { = H ( e ) + \\mathbb { E } _ { W \\sim p ( W ) } [ \\mathbb { E } _ { e \\sim p ( e | W ) } [ \\log p ( e | W ) - \\log q ( e | W ) + \\log q ( e | W ) ] ] } \\\\ { \\ } & { = H ( e ) + \\mathbb { E } _ { W \\sim p ( W ) } [ D _ { K L } ( p ( e | W ) \\| q ( e | W ) ) + \\mathbb { E } _ { e \\sim p ( e | W ) } [ \\log q ( e | W ) ] ] } \\\\ { \\ } & { \\geq H ( e ) + \\mathbb { E } _ { W \\sim p ( W ) } [ \\mathbb { E } _ { e \\sim p ( e | W ) } [ \\log q ( e | W ) ] ] } \\\\ { \\ } & { = H ( e ) + \\mathbb { E } _ { e \\sim p ( e ) , W \\sim p ( W | e ) } [ \\log q ( e | W ) ] } \\\\ { \\ } & { \\stackrel { ( a ) } { = } H ( e ) + \\mathbb { E } _ { e \\sim p ( e ) } [ \\log q ( e | f ( e ) ) ] } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            222,
+            123,
+            774,
+            262
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the equality ( $a$ ) follows from Eq. (5). ",
+        "bbox": [
+            173,
+            265,
+            485,
+            281
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "According to Theorem 1, we can maximize the variational lower bound for $I ( e ; W )$ . The bound becomes tight when the variational distribution $q ( e | W )$ approaches the true posterior $p ( e | W )$ . Moreover, $H ( e )$ is a constant because the distribution of edge feature vector $e$ is fixed for given graphs, hence we can equivalently maximize $\\mathcal { L } _ { I } ( f , g ; e )$ . We choose the widely accepted Gaussian distribution as the prior distribution for the probabilistic decoder $g$ , ",
+        "bbox": [
+            173,
+            295,
+            825,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f8a4483a3180430a353a9084a23a720e3b8ae44919cce3c219973627c201c39d.jpg",
+        "text": "$$\nq ( e | W ) = \\mathcal { N } ( e ; g ( W ) , \\sigma ^ { 2 } I ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            369,
+            596,
+            387
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then we have ",
+        "bbox": [
+            174,
+            391,
+            274,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f9aff49d6e2e211ee2f081b682d6476c98870ba18a9bff3393ceb13b8bcdb085.jpg",
+        "text": "$$\n\\mathcal { L } _ { I } ( f , g ; e ) = \\log q ( e | f ( e ) ) = \\log \\mathcal { N } ( e ; g ( f ( e ) ) , \\sigma ^ { 2 } I ) = - \\lambda \\| e - g ( f ( e ) ) \\| _ { 2 } ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            250,
+            410,
+            750,
+            428
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda > 0$ is a constant determined by $\\sigma$ and the dimension of $e$ , taken as a tunable parameter. The following Theorem 2 shows that maximizing the objective in Eq. (8) does lead to the maximization of $I ( e ; W )$ , hence enables the model to preserve edge information. ",
+        "bbox": [
+            174,
+            433,
+            825,
+            474
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. Assume the optimal solution of maximizing $\\mathcal { L } _ { I } ( f , g ; e )$ is $f ^ { \\star }$ and $g ^ { \\star }$ , then $f ^ { \\star }$ also maximizes $I ( e ; W )$ . ",
+        "bbox": [
+            173,
+            477,
+            821,
+            507
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Proof. Note that $H ( e )$ is a constant when the graphs are given. In information theory, we have ",
+        "bbox": [
+            169,
+            521,
+            821,
+            547
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2a778d2e9fad80245dd43235b7a2babb5068136039b0572e8acfda673570fcb7.jpg",
+        "text": "$$\nH ( g ( f ( e ) ) ) \\leq H ( f ( e ) ) \\leq H ( e ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            549,
+            611,
+            564
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$I ( e ; W )$ is upper bounded by $H ( e )$ , ",
+        "bbox": [
+            176,
+            566,
+            428,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a305eb6f7f8a26722c22a657ceb5288b473051298c22bbc93edee7a5d363b310.jpg",
+        "text": "$$\nI ( e ; W ) = I ( e ; f ( e ) ) = H ( f ( e ) ) - H ( f ( e ) | e ) = H ( f ( e ) ) \\leq H ( e ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            272,
+            588,
+            723,
+            603
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since $f ^ { \\star }$ and $g ^ { \\star }$ is the optimal solution of maximizing $\\mathcal { L } _ { I } ( f , g ; e )$ presented in Eq. (8), it is not difficult to see that $e = g ^ { \\star } ( f ^ { \\star } ( e ) ) , \\forall e \\in \\mathcal { E }$ . In this case, the inequalities in Eq. 9 become equalities, i.e., ",
+        "bbox": [
+            174,
+            607,
+            825,
+            648
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/809dfe6268777d2ba705ed212906089485ef5b8dcf78fafc8f140c20b3eecaed.jpg",
+        "text": "$$\nH ( g ^ { \\star } ( f ^ { \\star } ( e ) ) ) = H ( f ^ { \\star } ( e ) ) = H ( e ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            377,
+            650,
+            617,
+            665
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore, we have $I ( e ; W ) = H ( e )$ , i.e., the maximum is attained in this case. ",
+        "bbox": [
+            174,
+            666,
+            735,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 Edge Information Maximized Graph Neural Networks ",
+        "bbox": [
+            176,
+            695,
+            673,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our EIGNN is derived by implementing our MI objective in GNNs. As a concrete example, the forward propagation of our model follows the formulation in Eq. (3), where the dege network $f : e  W$ is expressed as a multi-layer perceptron (MLP). According to theoretical analysis presented in Sec. 3.2 , we introduce another MLP $g : W \\to e$ as the decoder. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            779
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For graph regression or classification tasks, the model outputs a prediction $y$ for each graph $G$ , which has label $\\hat { y }$ . Without MI maximization, we denote the vanilla loss as $\\mathcal { L } _ { 0 } ( \\hat { y } , y ; G )$ . Common choice of $\\mathcal { L } _ { 0 }$ includes Mean Square Error (MSE), Mean Absolute Error (MAE) and Cross Entropy (CE). For a graph $G = ( \\nu , \\mathcal { E } )$ , EIGNN maximizes $\\mathcal { L } _ { I } ( f , g ; e )$ and minimizes $\\mathcal { L } _ { 0 } ( \\hat { y } , y ; G )$ using the following loss function ",
+        "bbox": [
+            173,
+            785,
+            825,
+            856
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9ffed3d9ec064286879e4ca1479706a35dcaf6e9fa768bf67f604003845c77f.jpg",
+        "text": "$$\n\\mathcal { L } _ { E I G N N } ( G ) = \\mathcal { L } _ { 0 } ( \\hat { y } , y ; G ) - \\lambda \\mathbb { E } _ { e \\in \\mathcal { E } } [ \\mathcal { L } _ { I } ( f , g ; e ) ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            861,
+            666,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { E } _ { e \\in \\mathcal { E } } [ \\cdot ]$ denotes taking the mean over all edges in $G = ( \\nu , \\mathcal { E } )$ and $\\lambda$ is the regularization parameter. When EIGNN is trained using mini-batches, $\\mathcal { L } _ { 0 } ( \\hat { y } , y ; G )$ is averaged over all graphs in the batch while $\\mathcal { L } _ { I } ( f , g ; e )$ is averaged over all edges of all graphs in the batch. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Similarly, for relational prediction tasks in knowledge graphs, EIGNN directly yields nodelevel representations $h _ { v }$ for each node $v \\in \\mathcal V$ and edge-level representations $e$ for each relationship. The objective function of EIGNN can be derived from the translational scoring function Bordes et al. (2013), which learns embedding such that for a given valid triple $t _ { v w } = ( h _ { v } , e _ { v w } , h _ { w } )$ from the valid set $S$ , the condition $d _ { t _ { v w } } = h _ { v } + e _ { v w } - h _ { w } \\approx 0$ holds. Let $\\mathcal { L } _ { 0 } = \\mathbb { E } _ { t _ { v w } \\in S } \\mathbb { E } _ { t _ { v w } ^ { \\prime } \\in S ^ { \\prime } } \\operatorname* { m a x } \\{ d _ { t _ { v w } ^ { \\prime } } - d _ { t _ { v w } } + \\gamma , 0 \\}$ , where $S ^ { \\prime }$ denotes a set of invalid triples and $\\gamma$ is a margin hyper-parameter, EIGNN can be trained by minimizing the following loss, ",
+        "bbox": [
+            173,
+            102,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6b4942e4c4e30ad4a1ef853dea11681cee7cc1ec7a668a18ce808e38004cbe7e.jpg",
+        "text": "$$\n\\mathcal { L } _ { E I G N N } ( G ) = \\mathcal { L } _ { 0 } - \\lambda \\mathbb { E } _ { e \\in \\mathcal { E } } [ \\mathcal { L } _ { I } ( f , g ; e ) ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            209,
+            638,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            244,
+            333,
+            261
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first conduct experiments on a large quantum chemistry benchmark QM9, which is challenging for most baselines. Then we evaluate EIGNN on several useful molecule benchmarks and use attribution analysis to show that EIGNN increases the impact of edges and captures domain knowledge without human interference. Finally, we adopt our method to large-scale knowledge graphs and evaluate the performance on challenging relation prediction tasks using a wide variety of real-world datasets. All experimental results demonstrate a clear and substantial improvement of EIGNN over the state-of-the-art methods. ",
+        "bbox": [
+            173,
+            276,
+            825,
+            375
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 Quantum Chemistry ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            391,
+            382,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "QM9 (Ramakrishnan et al., 2014) is a large benchmark containing 134k molecules with 12 quantum chemistry regression properties, which have been show to be quite challenging for many GNNs (Gilmer et al., 2017). Feature engineering of nodes and edges exactly follows (Gilmer et al., 2017) such that molecules are preprocessed as graphs according to atom features and bond features. We compare our EIGNN with nine state-of-the-art baselines which can be categorized into three groups according to the ability of handling edge features: i) GCN, ChebyNet, GAT and GIN (Xu et al., 2019) which simply use binary edge features to indicate the existence of a bond without any other edge features; ii) RGCN, GGNN, LNet and simplified MPNN (sMPNN) which consider bond types (no bond, single, double, triple, or aromatic); iii) MPNN and our EIGNN which use edge feature vectors to indicate both edge types and pairwise distance between atoms. ",
+        "bbox": [
+            174,
+            417,
+            825,
+            570
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For a fair comparison, we repeat all experiments 3 times with different random seeds while during each run, all methods share the same random seed. We randomly choose 10k molecules for validation, 10k molecules for testing, and keep the rest for training. Each target property is normalized to zero mean and unit variance for training. Each model is trained to predict the 12 target properties simultaneously. $\\lambda$ is naively set to 1 for EIGNN. We use mean square error (MSE) loss to train the models for at most 300 epochs till convergence, and the performance is measured by mean absolute error (MAE). For LNet and GGNN, implementation of the readout function follows the original paper. While for all other models, we use the same set2set (Vinyals et al., 2015) readout, which has been demonstrated to work well in (Gilmer et al., 2017). ",
+        "bbox": [
+            174,
+            577,
+            825,
+            689
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/e2363b0c98ec786aa722ef1c4ce1f710a68fcc7b20e4906ed858c3a4646bd1e1.jpg",
+        "table_caption": [
+            "Table 1: Quantum property regressions for 12 targets and overall performance (top two raws) on QM9. We repeat all experiments 3 times with different random seeds and report the average performance. Full results with standard deviation are presented in Appendix A, e.g., for MPNN and EIGNN, we have Avg. nMAE $0 . 0 3 9 8 \\pm 0 . 0 0 0 2$ and 0.0357 ± 0.0005. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>GCN</td><td>ChebyNet</td><td>GAT</td><td>GIN</td><td>RGCN</td><td>GGNN</td><td>LNet</td><td>sMPNN</td><td>MPNN</td><td>EIGNN</td></tr><tr><td>Avg.nMAE</td><td>0.135</td><td>0.121</td><td>0.137</td><td>0.100</td><td>0.102</td><td>0.099</td><td>0.099</td><td>0.089</td><td>0.040</td><td>0.036</td></tr><tr><td>Avg.MAE</td><td>5.306</td><td>4.303</td><td>5.470</td><td>3.480</td><td>3.817</td><td>3.661</td><td>3.653</td><td>3.161</td><td>0.693</td><td>0.633</td></tr><tr><td>mu</td><td>0.568</td><td>0.518</td><td>0.567</td><td>0.478</td><td>0.506</td><td>0.518</td><td>0.472</td><td>0.472</td><td>0.110</td><td>0.097</td></tr><tr><td>alpha</td><td>0.881</td><td>0.793</td><td>0.891</td><td>0.621</td><td>0.632</td><td>0.608</td><td>0.623</td><td>0.528</td><td>0.332</td><td>0.294</td></tr><tr><td>HOMO(10-3)</td><td>5.451</td><td>4.775</td><td>5.429</td><td>4.183</td><td>4.453</td><td>4.483</td><td>3.889</td><td>3.854</td><td>2.481</td><td>2.230</td></tr><tr><td>LUMO(10-3)</td><td>6.400</td><td>5.674</td><td>6.331</td><td>4.796</td><td>5.138</td><td>5.153</td><td>4.194</td><td>4.549</td><td>2.862</td><td>2.593</td></tr><tr><td>gap(10-3)</td><td>8.201</td><td>7.097</td><td>8.193</td><td>6.096</td><td>6.500</td><td>6.602</td><td>5.813</td><td>5.634</td><td>3.620</td><td>3.275</td></tr><tr><td>R2</td><td>53.56</td><td>41.95</td><td>54.52</td><td>34.65</td><td>40.10</td><td>39.68</td><td>35.27</td><td>33.49</td><td>6.064</td><td>5.646</td></tr><tr><td>ZPVE(10-3)</td><td>2.533</td><td>2.527</td><td>2.271</td><td>1.744</td><td>1.477</td><td>1.292</td><td>1.438</td><td>1.345</td><td>0.679</td><td>0.612</td></tr><tr><td>UO</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.697</td><td>1.806</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>U</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.697</td><td>1.755</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>H</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.697</td><td>1.796</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>G</td><td>2.042</td><td>1.984</td><td>2.290</td><td>1.422</td><td>1.059</td><td>0.696</td><td>1.778</td><td>0.791</td><td>0.416</td><td>0.357</td></tr><tr><td>Cv</td><td>0.473</td><td>0.420</td><td>0.479</td><td>0.309</td><td>0.317</td><td>0.315</td><td>0.312</td><td>0.262</td><td>0.134</td><td>0.121</td></tr></table>",
+        "bbox": [
+            176,
+            762,
+            820,
+            920
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/b51754269df1a1a81766b31ec23b13e16833a1c14fe21641771ca4dfac60a05d.jpg",
+        "image_caption": [
+            "Figure 1: Ablation study. Training and validation error on QM9. The shadow area indicates $m e a n \\pm s t d$ over 3 runs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            99,
+            758,
+            246
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            287,
+            821,
+            316
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Table 1, we list regression results for all methods. We report individual MAE for each target in their original scale, averaged MAE (Avg. MAE) over 12 properties, and averaged normalized MAE (Avg. nMAE; averaged over normalized target properties since different targets have different units and ranges). Our EIGNN achieves the best performance for each metric and each target. Now we are ready to answer the following research questions. i) Are edge features important? Yes. The error has a trend of decreasing with increasing edge features. The comparison between sMPNN (using edge types) and MPNN (using edge types and distance) directly verifies the importance of edge features. It is also consistent with the expert knowledge that distances between pairwise atoms are closely related to quantum properties. For example, the smaller the distance between the two atoms, the stronger the bond is, and consequently a higher bond energy is associated with this atom pair. ii) Does the EIGNN work? Yes. EIGNN achieves the best performance on each target, outperforming the strong baseline MPNN. Moreover, the advantage of EIGNN over MPNN is consistent over 3 runs and the standard deviation on this task is quite small. Detailed results are shown in Table 4 of Appendix A. iii) How does the EIGNN work? Our MI objective is easily implemented on top of vanilla loss function. We have shown that our objective enables preserving of edge information. Fig. 1 demonstrates that regularization such as $L _ { 2 }$ weight decay can increase training error while our objective does not. Moreover, the validation performance verifies that regularization itself does not reduce the validation error. Thus, the effectiveness of EIGNN is due to exploiting edge features rather than the regularization effect. We further run an ablation study where we concatenate edge features to node representations (i.e., MPNN+concat in Fig. 1) in message passing. Concatenation is unable to identify correlations between edges and nodes (Gilmer et al., 2017) and our results show that it slightly reduces the mean validation error but increases the variance. ",
+        "bbox": [
+            173,
+            324,
+            825,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 More Molecule Benchmarks with Potential Applications ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            676,
+            700,
+            690
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We further evaluate EIGNN on three molecule benchmarks: Lipophilicity (Wu et al., 2018), ESOL (Delaney, 2004) and FreeSolv (Mobley & Guthrie, 2014). These datasets contain fewer molecules, and have potential usages in applications such as chemistry, drug discovery, and materials science. For example, the property lipophilicity is an important feature of drug molecules that affects both membrane permeability and solubility. The dataset Lipophilicity contains 4200 compounds. ESOL provides water solubility data for 1128 compounds. FreeSolv contains hydration free energy of 642 small molecules in water. We conduct graph regression experiments on these benchmarks. All datasets are split into training, validation and test according to a proportion of 0.8/0.1/0.1. MPNN and our EIGNN share the same architecture with 3 layers of message passing and 3 steps of set2set. We repeat each experiment 3 times with different random seeds. Results of testing root mean square error (RMSE) in Table 2 verify the effectiveness of our method. Our EIGNN outperforms MPNN on each dataset and each run. Detailed results for each run are presented in Appendix B. ",
+        "bbox": [
+            174,
+            703,
+            825,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/7582535dc47cc56dc3b59505e6ee0ff5b99c6069343599af156f76f4881db6c9.jpg",
+        "table_caption": [
+            "Table 2: Testing RMSE on Lipophilicity, ESOL and FreeSolv. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"2\">Lipophilicity</td><td colspan=\"2\">ESOL</td><td colspan=\"2\">FreeSolv</td></tr><tr><td>Method</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td></tr><tr><td>mean±std</td><td>0.678±0.042</td><td>0.653±0.025</td><td>0.805±0.064</td><td>0.776±0.071</td><td>1.398±0.081</td><td>1.273±0.137</td></tr></table>",
+        "bbox": [
+            178,
+            876,
+            820,
+            921
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/93a30757aa01764b32a397063bc6a0e3a215232f566f99e62524e437f83f0e93.jpg",
+        "image_caption": [
+            "Figure 2: Attribution analysis. The color indicates the impact of an edge/atom on the output, i.e., the regression result. EIGNN i) increases the edge attribution, ii) reduces the prediction error and iii) can learn domain knowledge without human interference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            99,
+            750,
+            311
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            369,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Attribution analysis. To understand how our EIGNN reduces the regression error, we conduct attribution analysis, i.e., attributing the prediction of a deep network to its input features, which usually builds up on the standard gradient operator (Sundararajan et al., features 2017). For an output $e$ as $\\begin{array} { r } { S _ { e } = | \\frac { \\partial y } { \\partial e } | } \\end{array}$ $y$ , i.e., the prediction of a GNN, we define its sensitivity to an edge with , where $\\left. \\cdot \\right.$ denotes the $L _ { 1 }$ norm. Similarly, the sensitivity to an atom with features $x$ is $\\begin{array} { r } { S _ { x } = | \\frac { \\partial y } { \\partial x } | } \\end{array}$ . Then $S _ { e }$ and $S _ { x }$ are used as the metrics of attribution in our experiments. As an example, we show in Fig. 2 the attribution for two molecules in Lipophilicity: (a) $N c I n o n c I C ( = N O ) N c \\mathcal { Q } c c c ( F ) c ( C l ) c \\mathcal { Q }$ and (b) Oc1c2ncc3ccccc3c2nn1c4ccccc4 . Molecule in (a) has the potential to be used to treat, prevent and/or diagnose cancer Prinz et al. (2019). Compared with MPNN, we can observe an increasing of overall edge attribution under our EIGNN and a decreasing of prediction error in both cases. Interestingly, the attribution under EIGNN is similar to the expert knowledge of chemists: halogen atoms such as {Cl, Br, I} and their bond with the carbon atom greatly effect the lipophilicity of a molecule Wilcken et al. (2013), while atoms {O, N} also have high impact on the lipophilicity but usually in a negative way (Augustijns & Brewster, 2007). In Fig. 2 (a), the attribution of the halogen bond C-Cl and the pair {O, N} under our EIGNN is much higher than the one under MPNN, which is consistent with the expert knowledge. In Fig. 2 (b), similarly, the attribution of atoms {O, N} and the bond C-O under EIGNN is much higher. More examples are presented in Appendix C. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            698
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 Predicting Relations in Knowledge Graphs ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            717,
+            581,
+            731
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we adopt EIGNN to tackle the problem of relation prediction in knowledge graphs (KGs), which entails predicting whether a given triple is valid or not. For example, a triple (London, capital of, United Kingdom) should be classified as valid or London should be predicted as the capital of United Kingdom. KGs represent human knowledge as a directed graph, and have been widely used in practical applications, such as semantic search, dialogue generation, question answering etc. Recovering missing relations in KGs have been a major task for practical usages of KGs. We evaluate our methods on three benchmark datasets, WN18RR (Dettmers et al., 2018), FB15k-237 (Toutanova et al., 2015) and NELL-995 (Xiong et al., 2017). Without the reversible relation problem (Dettmers et al., 2018), WN18RR includes 11 relations scraped from WordNet for 40, 943 synsets. FB15k-237 is a subset of Freebase, and contains 14, 541 entities associated with 237 types of edge. NELL-995 is constructed from the $9 9 5 ^ { t h }$ iteration of NELL system, containing 75, 492 entities and 200 types of edge. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/b9f6d05fff4b5da5ff97fa116ab1faa3e0ecaf14f59bf84883052dee805e45d1.jpg",
+        "table_caption": [
+            "Table 3: Experimental results on WN18RR, FB15K-237 and NELL-995 test sets. Hits@N values are in percentage. The best score is in bold and second best score is underlined. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"3\">Dataset</td><td colspan=\"4\">WN18RR</td><td colspan=\"4\">FB15K-237</td><td colspan=\"4\">NELL-995</td></tr><tr><td colspan=\"4\"></td><td rowspan=\"2\">MRR</td><td colspan=\"3\">Hit@N%</td><td rowspan=\"2\">MRR</td><td colspan=\"3\">Hit@N %</td></tr><tr><td>MRR</td><td>@1</td><td>@3</td><td>@10</td><td>@1</td><td>@3</td><td>@10</td><td>@1</td><td>@3</td><td>@10</td></tr><tr><td>DistMult</td><td>0.444</td><td>41.2</td><td>47</td><td>50.4</td><td>0.281</td><td>19.9</td><td>30.1</td><td>44.6</td><td>0.485</td><td>40.1</td><td>52.4</td><td>61</td></tr><tr><td>ComplEx</td><td>0.449</td><td>40.9</td><td>46.9</td><td>53</td><td>0.278</td><td>19.4</td><td>29.7</td><td>45</td><td>0.482</td><td>39.9</td><td>52.8</td><td>60.6</td></tr><tr><td>ConvE</td><td>0.456</td><td>41.9</td><td>47</td><td>53.1</td><td>0.312</td><td>22.5</td><td>34.1</td><td>49.7</td><td>0.491</td><td>40.3</td><td>53.1</td><td>61.3</td></tr><tr><td>TransE</td><td>0.243</td><td>42.7</td><td>44.1</td><td>53.2</td><td>0.279</td><td>19.8</td><td>37.6</td><td>44.1</td><td>0.401</td><td>34.4</td><td>47.2</td><td>50.1</td></tr><tr><td>ConvKB</td><td>0.265</td><td>58.2</td><td>44.5</td><td>55.8</td><td>0.289</td><td>19.8</td><td>32.4</td><td>47.1</td><td>0.43</td><td>37.0</td><td>47</td><td>54.5</td></tr><tr><td>R-GCN</td><td>0.123</td><td>8</td><td>13.7</td><td>20.7</td><td>0.164</td><td>10</td><td>18.1</td><td>30</td><td>0.12</td><td>8.2</td><td>12.6</td><td>18.8</td></tr><tr><td>KBGAT</td><td>0.436</td><td>35.8</td><td>48.1</td><td>57.8</td><td>0.431</td><td>36.1</td><td>45.8</td><td>56.9</td><td>0.514</td><td>42.9</td><td>55.3</td><td>67.8</td></tr><tr><td>EIGNN</td><td>0.438</td><td>35.7</td><td>48.8</td><td>58.1</td><td>0.451</td><td>37.4</td><td>48.2</td><td>60.5</td><td>0.523</td><td>43.8</td><td>56.1</td><td>68.3</td></tr></table>",
+        "bbox": [
+            186,
+            122,
+            810,
+            241
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A critical issue of applying Eq. (3) to KGs is that high-dimensional embedding vectors are required to distinguish massive amount of entities and relations, leading to a rapid growth in number of parameters in EIGNN. To address this issue, we adopt the architecture of (Nathani et al., 2019) and learn graph attention based embeddings that target relation prediction on KGs as follows, ",
+        "bbox": [
+            174,
+            263,
+            823,
+            335
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/56b7e18c1c9472053b2ca7278088a13ab3c9e8c0952468df13b763434be1907f.jpg",
+        "text": "$$\n\\begin{array} { r } { m _ { v w } = f \\big ( h _ { v } ^ { ( l ) } , e _ { v w } ^ { l } , h _ { w } ^ { ( l ) } \\big ) , \\alpha _ { v w } ^ { l } = \\mathrm { s o f t m a x } \\big ( a ^ { l } m _ { v w } ^ { l } \\big ) , h _ { v } ^ { ( l + 1 ) } = \\sigma \\left( \\sum _ { w \\in \\mathcal { N } _ { v } } \\alpha _ { v w } ^ { l } m _ { v w } ^ { l } \\right) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            197,
+            338,
+            772,
+            366
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Compared with Eq. (3), where $m _ { v w } = f ( e _ { v w } ) h _ { w }$ , the above equation absorbs the transform matrix $f ( e _ { v w } )$ into $f ( h _ { v } ^ { ( l ) } , e _ { v w } , h _ { w } ^ { ( l ) } )$ and reduces the model parameters. In the following experiments, we implement $f$ using a MLP as in previous experiments, and maximizes the MI between $e _ { v w }$ and $m _ { v w }$ by introducing another MLP with $\\lambda = 0 . 0 1$ . Multi-head attention is further introduced to stabilize the learning process and encapsulate more information about neighbors according to (Veličković et al., 2018). After training EIGNN, ConvKB (Nguyen et al., 2018) is adopted as a regression function for a given triple by analyzing the global embedding properties across each dimension. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            486
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In the relation prediction task, the aim is to predict a triple $( v , e _ { v w } , w )$ with $\\boldsymbol { v }$ or $w$ missing. We can generate a set of candidate triples for each missing entity $v$ by randomly replacing it with an arbitrary one. Scores can be calculated by ConvKB for all triples, and we find the rank of a correct triple by sorting all scores in ascending order. Thus, the performance of relation prediction task can be evaluated by mean reciprocal rank (MRR) and the proportion of correct entities in the top $N$ ranks (Hits@N) for $N = 1 , 3$ , and 10 (Bordes et al., 2013). We compare our EIGNN with seven state-of-the-art baselines focusing on this task: DistMult (Yang et al., 2014), ComplEx (Trouillon et al., 2016), ConvE (Dettmers et al., 2018), TransE (Bordes et al., 2013), ConvKB (Nguyen et al., 2018), RGCN (Schlichtkrull et al., 2018) and KBGAT (Nathani et al., 2019). As shown in Table 3, our EIGNN achieves the best performance for each metric on FB15K-237 and NELL-995, and achieves the best performance on WN18RR with Hit $^ \\mathrm { ( a 3 }$ and 10 metrics. The results of KBGAT are reproduced following the official implementation1, and the results of other methods can be found in the previous peer-reviewed publications, i.e. (Nathani et al., 2019). ",
+        "bbox": [
+            173,
+            492,
+            825,
+            686
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            705,
+            328,
+            722
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work, to make better use of edge features in GNNs, we proposed the edge information maximized graph neural network (EIGNN) that maximizes the mutual information between edge feature vectors and message passing channels. We reformulated the mutual information as a differentiable objective by adopting a variational approach. We have theoretically proved that our proposed objective enables EIGNN to preserve edge information and empirically evaluated EIGNN’s performance on a variety of benchmarks incorporating an array of challenging molecular datasets and knowledge graphs. These results clearly manifested a substantial improvement of EIGNN over the prior state-of-the-art methods. Apart from demonstrating the impressive performance of EIGNN, we also showed that its effectiveness is due to exploitation of edge features instead of the regularization effect. Notably, attribution analysis on molecular graphs show that EIGNN can capture domain knowledge in an end-to-end fashion. ",
+        "bbox": [
+            174,
+            737,
+            825,
+            904
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            290,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Barber Felix Agakov. The im algorithm: a variational approach to information maximization. NeurIPS, 2004. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Patrick Augustijns and Marcus E Brewster. Solvent systems and their selection in pharmaceutics and biopharmaceutics, volume 190. Springer, 2007. ",
+        "bbox": [
+            171,
+            165,
+            823,
+            194
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Barber and Felix V Agakov. Kernelized infomax clustering. In NeurIPS, 2006. ",
+        "bbox": [
+            173,
+            202,
+            787,
+            219
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Antoine Bordes, Nicolas Usunier, Alberto Garcia-Duran, Jason Weston, and Oksana Yakhnenko. Translating embeddings for modeling multi-relational data. In NeurIPS, pp. 2787–2795, 2013. ",
+        "bbox": [
+            176,
+            228,
+            823,
+            271
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John S Bridle, Anthony JR Heading, and David JC MacKay. Unsupervised classifiers, mutual information and’phantom targets. In NeurIPS, 1992. ",
+        "bbox": [
+            173,
+            281,
+            823,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xi Chen, Yan Duan, Rein Houthooft, John Schulman, Ilya Sutskever, and Pieter Abbeel. Infogan: interpretable representation learning by information maximizing generative adversarial nets. In NeurIPS, 2016. ",
+        "bbox": [
+            176,
+            319,
+            823,
+            363
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kyunghyun Cho, Bart Van Merriënboer, Dzmitry Bahdanau, and Yoshua Bengio. On the properties of neural machine translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014. ",
+        "bbox": [
+            174,
+            372,
+            823,
+            416
+        ],
+        "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 NeurIPS, 2016. ",
+        "bbox": [
+            173,
+            425,
+            825,
+            455
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "John S Delaney. Esol: estimating aqueous solubility directly from molecular structure. Journal of chemical information and computer sciences, 44(3):1000–1005, 2004. ",
+        "bbox": [
+            171,
+            464,
+            823,
+            494
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tim Dettmers, Pasquale Minervini, Pontus Stenetorp, and Sebastian Riedel. Convolutional 2d knowledge graph embeddings. In AAAI, 2018. ",
+        "bbox": [
+            173,
+            502,
+            823,
+            534
+        ],
+        "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 NeurIPS, 2015. ",
+        "bbox": [
+            176,
+            541,
+            823,
+            585
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. Neural message passing for quantum chemistry. In ICML, 2017. ",
+        "bbox": [
+            174,
+            594,
+            823,
+            625
+        ],
+        "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": [
+            176,
+            633,
+            823,
+            676
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In NeurIPS, pp. 1024–1034, 2017. ",
+        "bbox": [
+            174,
+            686,
+            823,
+            717
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "R Devon Hjelm, Alex Fedorov, Samuel Lavoie-Marchildon, Karan Grewal, Phil Bachman, Adam Trischler, and Yoshua Bengio. Learning deep representations by mutual information estimation and maximization. 2019. ",
+        "bbox": [
+            176,
+            724,
+            823,
+            768
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Weihua Hu, Bowen Liu, Joseph Gomes, Marinka Zitnik, Percy Liang, Vijay Pande, and Jure Leskovec. Pre-training graph neural networks. arXiv preprint arXiv:1905.12265, 2019. ",
+        "bbox": [
+            173,
+            777,
+            823,
+            808
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            173,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In ICLR, 2017. ",
+        "bbox": [
+            173,
+            856,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andreas Krause, Pietro Perona, and Ryan G Gomes. Discriminative clustering by regularized information maximization. In NeurIPS, 2010. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. Gated graph sequence neural networks. In ICLR, 2016. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Renjie Liao, Zhizhen Zhao, Raquel Urtasun, and Richard S Zemel. Lanczosnet: Multi-scale deep graph convolutional networks. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            140,
+            821,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ralph Linsker. Self-organization in a perceptual network. Computer, 21(3):105–117, 1988. ",
+        "bbox": [
+            174,
+            176,
+            818,
+            193
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David L Mobley and J Peter Guthrie. Freesolv: a database of experimental and calculated hydration free energies, with input files. Journal of computer-aided molecular design, 28 (7):711–720, 2014. ",
+        "bbox": [
+            173,
+            199,
+            821,
+            242
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher Morris, Martin Ritzert, Matthias Fey, William L Hamilton, Jan Eric Lenssen, Gaurav Rattan, and Martin Grohe. Weisfeiler and leman go neural: Higher-order graph neural networks. In AAAI, volume 33, pp. 4602–4609, 2019. ",
+        "bbox": [
+            178,
+            251,
+            823,
+            294
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Deepak Nathani, Jatin Chauhan, Charu Sharma, and Manohar Kaul. Learning attentionbased embeddings for relation prediction in knowledge graphs. The 57th Annual Meeting of the Association for Computational Linguistics (ACL), 2019. ",
+        "bbox": [
+            176,
+            300,
+            823,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dai Quoc Nguyen, Tu Dinh Nguyen, Dat Quoc Nguyen, and Dinh Phung. A novel embedding model for knowledge base completion based on convolutional neural network. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 2 (Short Papers), pp. 327–333, 2018. ",
+        "bbox": [
+            174,
+            351,
+            826,
+            409
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bianka Prinz, Jerry M Thomas, Ansgar Brock, Viviana Cremasco, Catherine Anne SabatosPeyton, Glenn Dranoff, Scott Chapel, Andrew Lake, Alison Paterson, Rachel W O’connor, et al. Antibody molecules to cd73 and uses thereof, January 31 2019. US Patent App. 16/014,744. ",
+        "bbox": [
+            173,
+            415,
+            826,
+            473
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Raghunathan Ramakrishnan, Pavlo O Dral, Matthias Rupp, and O Anatole Von Lilienfeld. Quantum chemistry structures and properties of 134 kilo molecules. Scientific data, 1: 140022, 2014. ",
+        "bbox": [
+            174,
+            481,
+            823,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1): 61–80, 2009. ",
+        "bbox": [
+            174,
+            531,
+            826,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. Modeling relational data with graph convolutional networks. In European Semantic Web Conference, pp. 593–607. Springer, 2018. ",
+        "bbox": [
+            174,
+            582,
+            826,
+            626
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mukund Sundararajan, Ankur Taly, and Qiqi Yan. Axiomatic attribution for deep networks. In ICML, pp. 3319–3328. JMLR. org, 2017. ",
+        "bbox": [
+            174,
+            632,
+            823,
+            662
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kristina Toutanova, Danqi Chen, Patrick Pantel, Hoifung Poon, Pallavi Choudhury, and Michael Gamon. Representing text for joint embedding of text and knowledge bases. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pp. 1499–1509, 2015. ",
+        "bbox": [
+            173,
+            669,
+            826,
+            727
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Théo Trouillon, Johannes Welbl, Sebastian Riedel, Éric Gaussier, and Guillaume Bouchard. Complex embeddings for simple link prediction. In ICML, pp. 2071–2080, 2016. ",
+        "bbox": [
+            174,
+            733,
+            823,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. In ICLR, 2018. ",
+        "bbox": [
+            174,
+            770,
+            823,
+            800
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Petar Veličković, William Fedus, William L Hamilton, Pietro Liò, Yoshua Bengio, and R Devon Hjelm. Deep graph infomax. In ICLR, 2019. ",
+        "bbox": [
+            174,
+            808,
+            823,
+            837
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint arXiv:1511.06391, 2015. ",
+        "bbox": [
+            174,
+            844,
+            821,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rainer Wilcken, Markus O Zimmermann, Andreas Lange, Andreas C Joerger, and Frank M Boeckler. Principles and applications of halogen bonding in medicinal chemistry and chemical biology. Journal of medicinal chemistry, 56(4):1363–1388, 2013. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhenqin Wu, Bharath Ramsundar, Evan N Feinberg, Joseph Gomes, Caleb Geniesse, Aneesh S Pappu, Karl Leswing, and Vijay Pande. Moleculenet: a benchmark for molecular machine learning. Chemical science, 9(2):513–530, 2018.   \nWenhan Xiong, Thien Hoang, and William Yang Wang. Deeppath: A reinforcement learning method for knowledge graph reasoning. In Proceedings of the 2017 Conference on Empirical Methods in Natural Language Processing, pp. 564–573, 2017.   \nKeyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? In ICLR, 2019.   \nBishan Yang, Wen-tau Yih, Xiaodong He, Jianfeng Gao, and Li Deng. Embedding entities and relations for learning and inference in knowledge bases. ICLR, 2014.   \nZhitao Ying, Jiaxuan You, Christopher Morris, Xiang Ren, Will Hamilton, and Jure Leskovec. Hierarchical graph representation learning with differentiable pooling. In NeurIPS, pp. 4800–4810, 2018.   \nJie Zhou, Ganqu Cui, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, and Maosong Sun. Graph neural networks: A review of methods and applications. arXiv preprint arXiv:1812.08434, 2018. ",
+        "bbox": [
+            171,
+            102,
+            826,
+            377
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A Full Results on QM9 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            426,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/a301b4667b007d0ca0d55c084b4ad788389f2f177ec6b78e47c696d5409f9f41.jpg",
+        "table_caption": [
+            "Table 4: Full results of quantum property regressions for 12 targets and overall performance (nMAE and MAE in top two raws) on QM9. We repeat all experiments 3 times with different random seeds and report the average performance and standard deviation. This is a supplement for Table 1. in the main text. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>GCN</td><td>ChebyNet</td><td>GAT</td><td>GIN</td></tr><tr><td>Avg.nMAE</td><td>0.1350±0.0046</td><td>0.1206±0.0084</td><td>0.1367±0.0050</td><td>0.1001±0.0007</td></tr><tr><td>Avg.MAE</td><td>5.3063±0.1964</td><td>4.3032±0.4814</td><td>5.4698±0.2040</td><td>3.4799±0.0402</td></tr><tr><td>mu</td><td>0.5679±0.0078</td><td>0.5180±0.0131</td><td>0.5670±0.0102</td><td>0.4783±0.0041</td></tr><tr><td>alpha</td><td>0.8811±0.0308</td><td>0.7932±0.0778</td><td>0.8913±0.0314</td><td>0.6209±0.0028</td></tr><tr><td>HOMO(10-3)</td><td>5.4510±0.0790</td><td>4.7750±0.2040</td><td>5.4290±0.1660</td><td>4.1830±0.0370</td></tr><tr><td>LUMO(10-3)</td><td>6.4000±0.1230</td><td>5.6740±0.2670</td><td>6.3310±0.2390</td><td>4.7960±0.0520</td></tr><tr><td>gap(10-3)</td><td>8.2010±0.2150</td><td>7.0970±0.3620</td><td>8.1930±0.2910</td><td>6.0960±0.0420</td></tr><tr><td>R2</td><td>53.563±1.0319</td><td>41.950±4.8289</td><td>54.519±1.5992</td><td>34.647±0.2167</td></tr><tr><td>ZPVE(10-3)</td><td>2.5330±0.1070</td><td>2.5270±0.3560</td><td>2.2710±0.1450</td><td>1.7440±0.0100</td></tr><tr><td>UO</td><td>2.0422±0.3281</td><td>1.9842±0.2035</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>U</td><td>2.0422±0.3281</td><td>1.9842±0.2035</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>H</td><td>2.0422±0.3281</td><td>1.9842±0.2035</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>G</td><td>2.0423±0.3281</td><td>1.9842±0.2036</td><td>2.2899±0.2000</td><td>1.4215±0.0857</td></tr><tr><td>Cv</td><td>0.4730±0.0209</td><td>0.4199±0.0499</td><td>0.4787±0.0164</td><td>0.3093±0.0035</td></tr><tr><td>Method</td><td>RGCN</td><td>GGNN</td><td>LNet</td><td>sMPNN</td></tr><tr><td>Avg.nMAE</td><td>0.1021±0.0016</td><td>0.0992±0.0013</td><td>0.0992±0.0061</td><td>0.0888±0.0014</td></tr><tr><td>Avg.MAE</td><td>3.8175±0.0605</td><td>3.6608±0.0723</td><td>3.6527±0.3417</td><td>3.1610±0.0697</td></tr><tr><td>mu</td><td>0.5056±0.0048</td><td>0.5179±0.0076</td><td>0.4717±0.0063</td><td>0.4718±0.0096</td></tr><tr><td>alpha</td><td>0.6321±0.0145</td><td>0.6077±0.0092</td><td>0.6225±0.0508</td><td>0.5278±0.0106</td></tr><tr><td>HOMO(10-3)</td><td>4.4530±0.1290</td><td>4.4830±0.0650</td><td>3.8889±0.1617</td><td>3.8540±0.0410</td></tr><tr><td>LUMO(10-3)</td><td>5.1380±0.1210</td><td>5.1530±0.0890</td><td>4.1935±0.2205</td><td>4.5490±0.0810</td></tr><tr><td>gap(10-3)</td><td>6.5000±0.1390</td><td>6.6020±0.1400</td><td>5.8132±0.6456</td><td>5.6340±0.0570</td></tr><tr><td>R2</td><td>40.102±0.7428</td><td>39.685±0.8212</td><td>35.275±3.0531</td><td>33.489±0.6562</td></tr><tr><td>ZPVE(10-3)</td><td>1.4770±0.0090</td><td>1.2920±0.0340</td><td>1.4376±0.0769</td><td>1.3450±0.0260</td></tr><tr><td>UO</td><td>1.0589±0.0231</td><td>0.6969±0.0413</td><td>1.8058±0.2533</td><td>0.7914±0.0446</td></tr><tr><td>U</td><td>1.0589±0.0231</td><td>0.6966±0.0418</td><td>1.7555±0.2196</td><td>0.7914±0.0446</td></tr><tr><td>H</td><td>1.0589±0.0231</td><td>0.6974±0.0408</td><td>1.7964±0.2428</td><td>0.7914±0.0446</td></tr><tr><td>G</td><td>1.0589±0.0231</td><td>0.6961±0.0421</td><td>1.7780±0.2458</td><td>0.7914±0.0446</td></tr><tr><td>Cv</td><td>0.3170±0.0152</td><td>0.3146±0.0125</td><td>0.3124±0.0303</td><td>0.2625±0.0040</td></tr><tr><td>Method</td><td>MPNN</td><td>EIGNN</td><td></td><td></td></tr><tr><td>Avg.nMAE</td><td>0.0398±0.0002</td><td>0.0357±0.0005</td><td></td><td></td></tr><tr><td>Avg.MAE</td><td>0.6929±0.0212</td><td>0.6331±0.0298</td><td></td><td></td></tr><tr><td>mu</td><td>0.1095±0.0014</td><td>0.0974±0.0026</td><td></td><td></td></tr><tr><td>alpha</td><td>0.3318±0.0026</td><td>0.2939±0.0054</td><td></td><td></td></tr><tr><td>HOMO(10-3)</td><td>2.4810±0.0200</td><td>2.2300±0.0310</td><td></td><td></td></tr><tr><td>LUMO(10-3)</td><td>2.8620±0.0370</td><td>2.5930±0.0440</td><td></td><td></td></tr><tr><td>gap(10-3)</td><td>3.6200±0.0180</td><td>3.2750±0.0520</td><td></td><td></td></tr><tr><td>R2</td><td>6.0637±0.2511</td><td>5.6464±0.3098</td><td></td><td></td></tr><tr><td>ZPVE(10-3)</td><td>0.6790±0.0140</td><td>0.6120±0.0170</td><td></td><td></td></tr><tr><td>UO</td><td>0.4164±0.0225</td><td>0.3574±0.0100</td><td></td><td></td></tr><tr><td>U</td><td>0.4164±0.0225</td><td>0.3575±0.0100</td><td></td><td></td></tr><tr><td>H</td><td>0.4164±0.0225</td><td>0.3574±0.0100</td><td></td><td></td></tr><tr><td>G</td><td>0.4164±0.0225</td><td>0.3575±0.0101</td><td></td><td></td></tr><tr><td>Cv</td><td>0.1339±0.0013</td><td>0.1208±0.0027</td><td></td><td></td></tr></table>",
+        "bbox": [
+            243,
+            202,
+            753,
+            738
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We present full results of quantum property regressions on QM9 with average performance and standard deviation in Table 4. The $( 1 0 ^ { - 3 }$ ) in the parentheses indicates that the values in the corresponding raw of the table should multiply by $1 0 ^ { - 3 }$ . This is simply for clear presentation of the values. We also present a detailed descriptions on the target properties in Table 5 for your reference. ",
+        "bbox": [
+            173,
+            750,
+            825,
+            819
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In our results, we directly report MAE instead of Error Ratio [(MAE)/(Chemical Accuracy) (Gilmer et al., 2017)], because it is common to report MAE in terms of chemical unit. This practice has been widely adopted not only in computational chemistry but also in the machine learning community working on molecular graphs (Wu et al., 2018; Morris et al., 2019). Still, we add Table 6 which contains the Error Ratio for MPNN and our EIGNN. In this comparison, we follow (Gilmer et al., 2017) and train models separately to predict each target. Our EIGNN consistently outperforms MPNN. ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/91a3cbe5a783bcdbe8a1afa2b6c12f24ae9c429e52bd0844c20c200534394b6c.jpg",
+        "table_caption": [
+            "Table 5: Regression targets on QM9. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Target property</td><td>Description</td><td>Unit</td></tr><tr><td>mu</td><td>Dipole moment</td><td>D</td></tr><tr><td>alpha</td><td>Isotropic polarizability</td><td>a</td></tr><tr><td>HOMO</td><td>Highest occupied molecular orbital energy</td><td>Eh</td></tr><tr><td>LUMO</td><td>Lowest unoccupied molecular orbital energy</td><td>Eh</td></tr><tr><td>gap</td><td>Gap between HOMO and LUMO</td><td>Eh</td></tr><tr><td>R2</td><td>Electronic spatial extent</td><td>品</td></tr><tr><td>ZPVE</td><td>Zero point vibrational energy</td><td>Eh</td></tr><tr><td>UO</td><td>Internal energy at OK</td><td>Eh</td></tr><tr><td>U</td><td>Internal energy at 298.15K</td><td>Eh</td></tr><tr><td>H</td><td>Enthalpy at 298.15K</td><td>Eh</td></tr><tr><td>G</td><td>Free energy at 298.15K</td><td>Eh</td></tr><tr><td>Cv</td><td>Heat capavity at 298.15K</td><td>cal molK</td></tr></table>",
+        "bbox": [
+            281,
+            127,
+            717,
+            275
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/2c21c7621d41da0431991f555ba9609c7ac7f048f42d5cf034e99ce8a99c7454.jpg",
+        "table_caption": [
+            "Table 6: Error Ratio [(MAE)/(Chemical Accuracy) (Gilmer et al., 2017)] on QM9. Note that the energy values of $\\{ \\mathrm { U 0 , ~ U , ~ H , ~ G } \\}$ are per molecule rather than per atom. Following (Gilmer et al., 2017), models are separately trained on each target. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Target</td><td>MPNN</td><td>EIGNN</td><td>Improvement (%)</td></tr><tr><td>mu</td><td>0.87</td><td>0.80</td><td>8.24</td></tr><tr><td>alpha</td><td>2.64</td><td>2.44</td><td>7.57</td></tr><tr><td>HOMO</td><td>1.54</td><td>1.39</td><td>10.2</td></tr><tr><td>LUMO</td><td>1.31</td><td>1.28</td><td>2.13</td></tr><tr><td>gap</td><td>2.20</td><td>1.97</td><td>10.4</td></tr><tr><td>R2</td><td>1.00</td><td>0.72</td><td>28.4</td></tr><tr><td>ZPVE</td><td>5.31</td><td>4.43</td><td>16.5</td></tr><tr><td>UO</td><td>64.3</td><td>35.8</td><td>44.4</td></tr><tr><td>U</td><td>56.6</td><td>23.6</td><td>58.3</td></tr><tr><td>H</td><td>77.4</td><td>35.2</td><td>54.5</td></tr><tr><td>G</td><td>46.6</td><td>34.4</td><td>26.1</td></tr><tr><td>Cv</td><td>1.69</td><td>1.79</td><td>-6.22</td></tr></table>",
+        "bbox": [
+            346,
+            345,
+            650,
+            491
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B Full Results on Lipophilicity, ESOL and FreeSolv ",
+        "bbox": [
+            173,
+            515,
+            717,
+            534
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present experimental results on Lipophilicity, ESOL and FreeSolv with detailed results for each run. The results in Table 7 verify that our EIGNN consistently outperforms MPNN. ",
+        "bbox": [
+            174,
+            549,
+            823,
+            590
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C More Examples of Attribution ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            611,
+            524,
+            627
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present more examples of attribution analysis on Lipophilicity. As a supplement for Fig. 2 in the main text, the observation here is similar. Compared with MPNN, we can observe an increasing of overall edge attribution under our EIGNN and a decreasing of prediction error in both cases. Notably, our EIGNN is able to capture the expert knowledge. (a) The molecule is $C N [ C @ \\mathbb { Q } H ] ( C ) C ( = O ) N [ C @ \\mathbb { Q } H ] ( C 1 C C C C T 1 ) C ( =$ $O ) N [ C @ H ] 2 C C C N ( C C c ( F ) c c 3 ) C 2$ . The attribution of $\\{ \\mathrm { O } , \\mathrm { N } \\}$ and the halogen atom $\\mathrm { F }$ is higher under EIGNN. (b) The molecule is $C C ( C ) N 1 C C N [ C @ H ] ( C 1 ) C ( =$ $O ) N 2 C C N ( C C 2 ) C ( = O ) N c 3 c c c ( C l ) c ( C l ) c 3$ . Our EIGNN successfully captures the importance of two critical halogen atoms Cl and several atoms N. (c) The molecule is $C O c 1 c c ( c c 1 ) C ( = \\ O ) N 2 C C C C 2 \\ = \\ O$ . The attribution of two atoms $\\mathrm { \\ o }$ at the top is ",
+        "bbox": [
+            173,
+            643,
+            825,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/901ad24ad330961b104145c59ad458a6aba349587ab22792703374b07939c3f2.jpg",
+        "table_caption": [
+            "Table 7: Testing RMSE on Lipophilicity, ESOL and FreeSolv. This is a supplement for Table 2 in the main text. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"2\">Lipophilicity</td><td colspan=\"2\">ESOL</td><td colspan=\"2\">FreeSolv</td></tr><tr><td>Seed</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td><td>MPNN</td><td>EIGNN</td></tr><tr><td>0</td><td>0.718</td><td>0.676</td><td>0.770</td><td>0.718</td><td>1.396</td><td>1.109</td></tr><tr><td>1</td><td>0.696</td><td>0.664</td><td>0.750</td><td>0.733</td><td>1.299</td><td>1.265</td></tr><tr><td>2</td><td>0.620</td><td>0.619</td><td>0.894</td><td>0.876</td><td>1.499</td><td>1.443</td></tr><tr><td>mean±std</td><td>0.678±0.042</td><td>0.653±0.025</td><td>0.805±0.064</td><td>0.776±0.071</td><td>1.398±0.081</td><td>1.273±0.137</td></tr></table>",
+        "bbox": [
+            178,
+            845,
+            818,
+            921
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "much higher under EIGNN. (d) The molecule is $C c 1 c c 2 N C ( = O ) C ( = C C ( = O ) c 2 c c 1 C ) O$ .   \nThe attribution of atoms O is much higher under EIGNN. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/d35b4c5026ccc9e9cd8864632869ef2ae4dd487409a61f9850c2293c8640530b.jpg",
+        "image_caption": [
+            "Figure 3: More examples of attribution analysis. The color indicates the impact of an edge/atom on the output, i.e., the regression result. EIGNN i) increases the edge attribution, ii) reduces the prediction error and iii) can learn domain knowledge without human interference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            147,
+            818,
+            667
+        ],
+        "page_idx": 13
+    }
+]

parse/train/ByxdUySKvS/ByxdUySKvS.md

@@ -0,0 +1,310 @@
+# ADVERSARIAL AUTOAUGMENT
+
+Xinyu Zhang   
+Huawei   
+zhangxinyu10@huawei.com   
+Qiang Wang   
+Huawei   
+wangqiang168@huawei.com   
+Jian Zhang   
+Huawei   
+zhangjian157@huawei.com   
+Zhao Zhong   
+Huawei   
+zorro.zhongzhao@huawei.com
+
+# ABSTRACT
+
+Data augmentation (DA) has been widely utilized to improve generalization in training deep neural networks. Recently, human-designed data augmentation has been gradually replaced by automatically learned augmentation policy. Through finding the best policy in well-designed search space of data augmentation, AutoAugment (Cubuk et al., 2019) can significantly improve validation accuracy on image classification tasks. However, this approach is not computationally practical for large-scale problems. In this paper, we develop an adversarial method to arrive at a computationally-affordable solution called Adversarial AutoAugment, which can simultaneously optimize target related object and augmentation policy search loss. The augmentation policy network attempts to increase the training loss of a target network through generating adversarial augmentation policies, while the target network can learn more robust features from harder examples to improve the generalization. In contrast to prior work, we reuse the computation in target network training for policy evaluation, and dispense with the retraining of the target network. Compared to AutoAugment, this leads to about $1 2 \times$ reduction in computing cost and $1 1 \times$ shortening in time overhead on ImageNet. We show experimental results of our approach on CIFAR-10/CIFAR-100, ImageNet, and demonstrate significant performance improvements over state-of-the-art. On CIFAR-10, we achieve a top-1 test error of $1 . 3 6 \%$ , which is the currently best performing single model. On ImageNet, we achieve a leading performance of top-1 accuracy $7 9 . 4 0 \%$ on ResNet-50 and $8 0 . 0 0 \%$ on ResNet-50-D without extra data.
+
+# 1 INTRODUCTION
+
+Massive amount of data have promoted the great success of deep learning in academia and industry. The performance of deep neural networks (DNNs) would be improved substantially when more supervised data is available or better data augmentation method is adapted. Data augmentation such as rotation, flipping, cropping, etc., is a powerful technique to increase the amount and diversity of data. Experiments show that the generalization of a neural network can be efficiently improved through manually designing data augmentation policies. However, this needs lots of knowledge of human expert, and sometimes shows the weak transferability across different tasks and datasets in practical applications. Inspired by neural architecture search (NAS)(Zoph & Le, 2016; Zoph et al., 2017; Zhong et al., 2018a;b; Guo et al., 2018), a reinforcement learning (RL) (Williams, 1992) method called AutoAugment is proposed by Cubuk et al. (2019), which can automatically learn the augmentation policy from data and provide an exciting performance improvement on image classification tasks. However, the computing cost is huge for training and evaluating thousands of sampled policies in the search process. Although proxy tasks, i.e., smaller models and reduced datasets, are taken to accelerate the searching process, tens of thousands of GPU-hours of consumption are still required. In addition, these data augmentation policies optimized on proxy tasks are not guaranteed to be optimal on the target task, and the fixed augmentation policy is also sub-optimal for the whole training process.
+
+![](images/30303714f451b21eaee42acd79567fecfdfac2cdfb67ff8adc6f2486bb4f5ec4.jpg)  
+Figure 1: The overview of our proposed method. We formulate it as a Min-Max game. The data of each batch is augmented by multiple pre-processing components with sampled policies $\{ \tau _ { 1 } , \tau _ { 2 } , \cdots , \tau _ { M } \}$ , respectively. Then, a target network is trained to minimize the loss of a large batch, which is formed by multiple augmented instances of the input batch. We extract the training losses of a target network corresponding to different augmentation policies as the reward signal. Finally, the augmentation policy network is trained with the guideline of the processed reward signal, and aims to maximize the training loss of the target network through generating adversarial policies.
+
+In this paper, we propose an efficient data augmentation method to address the problems mentioned above, which can directly search the best augmentation policy on the full dataset during training a target network, as shown in Figure 1. We first organize the network training and augmentation policy search in an adversarial and online manner. The augmentation policy is dynamically changed along with the training state of the target network, rather than fixed throughout the whole training process like normal AutoAugment (Cubuk et al., 2019). Due to reusing the computation in policy evaluation and dispensing with the retraining of the target network, the computing cost and time overhead are extremely reduced. Then, the augmentation policy network is taken as an adversary to explore the weakness of the target network. We augment the data of each min-batch with various adversarial policies in parallel, rather than the same data augmentation taken in batch augmentation (BA) (Hoffer et al., 2019). Then, several augmented instances of each mini-batch are formed into a large batch for target network learning. As an indicator of the hardness of augmentation policies, the training losses of the target network are used to guide the policy network to generate more aggressive and efficient policies based on REINFORCE algorithm (Williams, 1992). Through adversarial learning, we can train the target network more efficiently and robustly.
+
+The contributions can be summarized as follows:
+
+• Our method can directly learn augmentation policies on target tasks, i.e., target networks and full datasets, with a quite low computing cost and time overhead. The direct policy search avoids the performance degradation caused by the policy transfer from proxy tasks to target tasks.   
+• We propose an adversarial framework to jointly optimize target network training and augmentation policy search. The harder samples augmented by adversarial policies are constantly fed into the target network to promote robust feature learning. Hence, the generalization of the target network can be significantly improved.   
+• The experiment results show that our proposed method outperforms previous augmentation methods. For instance, we achieve a top-1 test error of $1 . 3 6 \%$ with PyramidNet+ShakeDrop (Yamada et al., 2018) on CIFAR-10, which is the state-of-the-art performance. On ImageNet, we improve the top-1 accuracy of ResNet-50 (He et al., 2016) from $7 6 . 3 \%$ to $7 9 . 4 \%$ without extra data, which is even $1 . 7 7 \%$ better than AutoAugment (Cubuk et al., 2019).
+
+# 2 RELATED WORK
+
+Common data augmentation, which can generate extra samples by some label-preserved transformations, is usually used to increase the size of datasets and improve the generalization of networks, such as on MINST, CIFAR-10 and ImageNet (Krizhevsky et al., 2012; Wan et al., 2013; Szegedy et al., 2015). However, human-designed augmentation policies are specified for different datasets. For example, flipping, the widely used transformation on CIFAR-10/CIFAR-100 and ImageNet, is not suitable for MINST, which will destroy the property of original samples.
+
+Hence, several works (Lemley et al., 2017; Cubuk et al., 2019; Lin et al., 2019; Ho et al., 2019) have attempted to automatically learn data augmentation policies. Lemley et al. (2017) propose a method called Smart Augmentation, which merges two or more samples of a class to improve the generalization of a target network. The result also indicates that an augmentation network can be learned when a target network is being training. Through well designing the search space of data augmentation policies, AutoAugment (Cubuk et al., 2019) takes a recurrent neural network (RNN) as a sample controller to find the best data augmentation policy for a selected dataset. To reduce the computing cost, the augmentation policy search is performed on proxy tasks. Population based augmentation (PBA) (Ho et al., 2019) replaces the fixed augmentation policy with a dynamic schedule of augmentation policy along with the training process, which is mostly related to our work. Inspired by population based training (PBT) (Jaderberg et al., 2017), the augmentation policy search problem in PBA is modeled as a process of hyperparameter schedule learning. However, the augmentation schedule learning is still performed on proxy tasks. The learned policy schedule should be manually adjusted when the training process of a target network is non-matched with proxy tasks.
+
+Another related topic is Generative Adversarial Networks (GANs) (Goodfellow et al., 2014), which has recently attracted lots of research attention due to its fascinating performance, and also been used to enlarge datasets through directly synthesizing new images (Tran et al., 2017; Perez & Wang, 2017; Antoniou et al., 2017; Gurumurthy et al., 2017; Frid-Adar et al., 2018). Although we formulate our proposed method as a Min-Max game, there exists an obvious difference with traditional GANs. We want to find the best augmentation policy to perform image transformation along with the training process, rather than synthesize new images. Peng et al. (2018) also take such an idea to optimize the training process of a target network in human pose estimation.
+
+# 3 METHOD
+
+In this section, we present the implementation of Adversarial AutoAugment. First, the motivation for the adversarial relation between network learning and augmentation policy is discussed. Then, we introduce the search space with the dynamic augmentation policy. Finally, the joint framework for network training and augmentation policy search is presented in detail.
+
+# 3.1 MOTIVATIONS
+
+Although some human-designed data augmentations have been used in the training of DNNs, such as randomly cropping and horizontally flipping on CIFAR-10/CIFAR-100 and ImageNet, limited randomness will make it very difficult to generate effective samples at the tail end of the training. To struggle with the problem, more randomness about image transformation is introduced into the search space of AutoAugment (Cubuk et al., 2019) (described in Section 3.2). However, the learned policy is fixed for the entire training process. All of possible instances of each example will be send to the target network repeatedly, which still results in an inevitable overfitting in a long-epoch training. This phenomenon indicates that the learned policy is not adaptive to the training process of a target network, especially found on proxy tasks. Hence, the dynamic and adversarial augmentation policy with the training process is considered as the crucial feature in our search space.
+
+Another consideration is how to improve the efficiency of the policy search. In AutoAugment (Cubuk et al., 2019), to evaluate the performance of augmentation policies, a lot of child models should be trained from scratch nearly to convergence. The computation in training and evaluating the performance of different sampled policies can not be reused, which leads to huge waste of computation resources. In this paper, we propose a computing-efficient policy search framework through reusing prior computation in policy evaluation. Only one target network is used to evaluate the performance of different policies with the help of the training losses of corresponding augmented instances. The augmentation policy network is learned from the intermediate state of the target network, which makes generated augmentation policies more aggressive and adaptive. On the contrary, to combat harder examples augmented by adversarial policies, the target network has to learn more robust features, which makes the training more efficiently.
+
+![](images/cf1281f8bae28f7b31d6aab6d29d8044913d73f1d9a58a90985849e432656219.jpg)  
+Figure 2: An example of dynamic augmentation policies learned with ResNet-50 on ImageNet. With the training process of the target network, harder augmentation policies are sampled to combat overfitting. Intuitively, more geometric transformations, such as TranslateX, ShearY and Rotate, are picked in our sampled policies, which is obviously different from AutoAugment (Cubuk et al., 2019) concentrating on color-based transformations.
+
+# 3.2 SEARCH SPACE
+
+In this paper, the basic structure of the search space of AutoAugment (Cubuk et al., 2019) is reserved. An augmentation policy is defined as that it is composed by 5 sub-policies, each sub-policy contains two image operations to be applied orderly, each operation has two corresponding parameters, i.e., the probability and magnitude of the operation. Finally, the 5 best policies are concatenated to form a single policy with 25 sub-policies. For each image in a mini-batch, only one sub-policy will be randomly selected to be applied. To compare with AutoAugment (Cubuk et al., 2019) conveniently, we just slightly modify the search space with removing the probability of each operation. This is because that we think the stochasticity of an operation with a probability requires a certain epochs to take effect, which will detain the feedback of the intermediate state of the target network. There are totally 16 image operations in our search space, including ShearX/Y, TranslateX/Y, Rotate, AutoContrast, Invert, Equalize, Solarize, Posterize, Contrast, Color, Brightness, Sharpness, Cutout (Devries & Taylor, 2017) and Sample Pairing (Inoue, 2018). The range of the magnitude is also discretized uniformly into 10 values. To guarantee the convergence during adversarial learning, the magnitude of all the operations are set in a moderate range.1 Besides, the randomness during the training process is introduced into our search space. Hence, the search space of the policy in each epoch has $| S | = ( 1 6 \times 1 0 ) ^ { 1 0 } \approx 1 . 1 \times 1 0 ^ { 2 2 }$ possibilities. Considering the dynamic policy, the number of possible policies with the whole training process can be expressed as $| S | ^ { \# e p o c h s }$ . An example of dynamically learning the augmentation policy along with the training process is shown in Figure 2. We observe that the magnitude (an indication of difficulty) gradually increases with the training process.
+
+# 3.3 ADVERSARIAL LEARNING
+
+In this section, the adversarial framework of jointly optimizing network training and augmentation policy search is presented in detail. We use the augmentation policy network $\boldsymbol { \mathcal { A } } ( \cdot , \pmb { \theta } )$ as an adversary, which attempts to increase the training loss of the target network $\mathcal { F } ( \cdot , w )$ through adversarial learning. The target network is trained by a large batch formed by multiple augmented instances of each batch to promote invariant learning (Salazar et al., 2018), and the losses of different augmentation policies applied on the same data are used to train the augmentation policy network by RL algorithm.
+
+Considering the target network $\mathcal { F } ( \cdot , w )$ with a loss function $\mathcal { L } [ \mathcal { F } ( \pmb { x } , \pmb { w } ) , \pmb { y } ]$ , where each example is transformed by some random data augmentation $o ( \cdot )$ , the learning process of the target network can be defined as the following minimization problem
+
+$$
+\pmb { w } ^ { * } = \underset { \pmb { w } } { \arg \operatorname* { m i n } } \ \underset { \pmb { x } \sim \Omega } { \mathbb { E } } \mathcal { L } [ \mathcal { F } ( o ( \pmb { x } ) , \pmb { w } ) , \pmb { y } ] ,
+$$
+
+where $\Omega$ is the training set, $_ { \textbf { \em x } }$ and $\textbf {  { y } }$ are the input image and the corresponding label, respectively. The problem is usually solved by vanilla SGD with a learning rate $\eta$ and batch size $N$ , and the training procedure for each batch can be expressed as
+
+$$
+\pmb { w } _ { t + 1 } = \pmb { w } _ { t } - \eta \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \nabla _ { \pmb { w } } \mathcal { L } [ \mathcal { F } ( o ( x _ { n } ) , \pmb { w } , y _ { n } ] .
+$$
+
+To improve the convergence performance of DNNs, more random and efficient data augmentation is performed under the help of the augmentation policy network. Hence, the minimization problem should be slightly modified as
+
+$$
+\pmb { w } ^ { * } = \underset { \pmb { w } } { \arg \operatorname* { m i n } } \ \underset { \pmb { x } \sim \Omega } { \mathbb { E } } \ \underset { \pmb { \mathcal { A } } ( \cdot , \pmb { \theta } ) } { \mathbb { E } } \mathcal { L } [ \mathcal { F } ( \tau ( \pmb { x } ) , \pmb { w } ) , \pmb { y } ] ,
+$$
+
+where $\tau ( \cdot )$ represents the augmentation policy generated by the network $\boldsymbol { \mathcal { A } } ( \cdot , \pmb { \theta } )$ . Accordingly, the training rule can be rewritten as
+
+$$
+\pmb { w } _ { t + 1 } = \pmb { w } _ { t } - \eta \frac { 1 } { M \cdot N } \sum _ { m = 1 } ^ { M } \sum _ { n = 1 } ^ { N } \nabla _ { \pmb { w } } \mathcal { L } [ \mathcal { F } ( \tau _ { m } ( x _ { n } ) , \pmb { w } ) , y _ { n } ] ,
+$$
+
+where we introduce $M$ different instances of each input example augmented by adversarial policies $\{ \tau _ { 1 } , \tau _ { 2 } , \cdots , \tau _ { M } \}$ . For convenience, we denote the training loss of a mini-batch corresponding to the augmentation policy $\tau _ { m }$ as
+
+$$
+\mathcal { L } _ { m } = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \mathcal { L } [ \mathcal { F } ( \tau _ { m } ( x _ { n } ) , \pmb { w } ) , y _ { n } ] .
+$$
+
+Hence, we have an equivalent form of Equation 4
+
+$$
+\pmb { w } _ { t + 1 } = \pmb { w } _ { t } - \eta \frac { 1 } { M } \sum _ { m = 1 } ^ { M } \nabla _ { \pmb { w } } \mathcal { L } _ { m } .
+$$
+
+Note that the training procedure can be regarded as a larger $N \cdot M$ batch training or an average over $M$ instances of gradient computation without changing the learning rate, which will lead to a reduction of gradient variance and a faster convergence of the target network Hoffer et al. (2019). However, overfitting will also come. To overcome the problem, the augmentation policy network is designed to increase the training loss of the target network with harder augmentation policies. Therefore, we can mathematically express the object as the following maximization problem
+
+$$
+\begin{array} { c } { \pmb { \theta } ^ { * } = \underset { \pmb { \theta } } { \arg \operatorname* { m a x } } J ( \pmb { \theta } ) , } \\ { \mathrm { w h e r e } ~ J ( \pmb { \theta } ) = \underset { \pmb { x } \sim \Omega } { \mathbb { E } } ~ \underset { \pmb { \mathbb { E } } ( \cdot , \pmb { \theta } ) } { \mathbb { E } } \mathcal { L } [ \mathcal { F } ( \tau ( \pmb { x } ) , \pmb { w } ) , \pmb { y } ] . } \end{array}
+$$
+
+Similar to AutoAugment (Cubuk et al., 2019), the augmentation policy network is also implemented as a RNN shown in Figure 3. At each time step of the RNN controller, the softmax layer will predict an action corresponding to a discrete parameter of a sub-policy, and then an embedding of the predicted action will be fed into the next time step. In our experiments, the RNN controller will predict 20 discrete parameters to form a whole policy.
+
+![](images/d2f4b35084c6e611d6139d1fbef94757f5d6b6d525d6edbd65d47563cffa3f4c.jpg)  
+Figure 3: The basic architecture of the controller for generating a sub-policy, which consists of two operations with corresponding parameters, the type and magnitude of each operation. When a policy contains $Q$ sub-policies, the basic architecture will be repeated $Q$ times. Following the setting of AutoAugment (Cubuk et al., 2019), the number of sub-policies $Q$ is set to 5 in this paper.
+
+However, there has a severe problem in jointly optimizing target network training and augmentation policy search. This is because that non-differentiable augmentation operations break gradient flow from the target network $\mathcal { F }$ to the augmentation policy network $\mathcal { A }$ (Wang et al., 2017; Peng et al., 2018). As an alternative approach, REINFORCE algorithm (Williams, 1992) is applied to optimize the augmentation policy network as
+
+$$
+\begin{array} { r l } & { \nabla _ { \theta } J ( \theta ) = \nabla _ { \theta } \underset { x \sim \Omega \tau \sim A ( \cdot , \theta ) } { \mathbb { E } } ~ \underset { { A } ^ { ( \cdot ) } } { \mathbb { E } } ~ \mathcal { L } [ \mathcal { F } ( \tau ( x ) , w ) , y ] } \\ & { \approx \displaystyle \sum _ { m } \mathcal { L } _ { m } \nabla _ { \theta } p _ { m } = \sum _ { m } \mathcal { L } _ { m } p _ { m } \nabla _ { \theta } \log p _ { m } } \\ & { ~ = \underset { { \tau \sim A ( \cdot , \theta ) } } { \mathbb { E } } ~ \mathcal { L } _ { m } \nabla _ { \theta } \log p _ { m } } \\ & { ~ \approx \frac { 1 } { M } \displaystyle \sum _ { m = 1 } ^ { M } \mathcal { L } _ { m } \nabla _ { \theta } \log p _ { m } , } \end{array}
+$$
+
+where $p _ { m }$ represents the probability of the policy $\tau _ { m }$ . To reduce the variance of gradient $\nabla _ { \pmb { \theta } } J ( \pmb { \theta } )$ , we replace the training loss of a mini-batch ${ \mathcal { L } } _ { m }$ with ${ \widehat { \mathcal { L } } } _ { m }$ a moving average over a certain minibatches2, and then normalize it among $M$ instances as ${ \widetilde { \mathcal { L } } } _ { m }$ . Hence, the training procedure of the augmentation policy network can be expressed as
+
+$$
+\begin{array} { r l } & { \nabla _ { \pmb { \theta } } J ( \pmb { \theta } ) \approx \cfrac { 1 } { M } \displaystyle \sum _ { m = 1 } ^ { M } \widetilde { \mathcal { L } } _ { m } \nabla _ { \pmb { \theta } } \log p _ { m } , } \\ & { \theta _ { e + 1 } = \theta _ { e } + \beta \displaystyle \frac { 1 } { M } \displaystyle \sum _ { m = 1 } ^ { M } \widetilde { \mathcal { L } } _ { m } \nabla _ { \pmb { \theta } } \log p _ { m } , } \end{array}
+$$
+
+The adversarial learning of target network training and augmentation policy search is summarized as Algorithm 1.
+
+# 4 EXPERIMENTS AND ANALYSIS
+
+In this section, we first reveal the details of experiment settings. Then, we evaluate our proposed method on CIFAR-10/CIFAR-100, ImageNet, and compare it with previous methods. Results in Figure 4 show our method achieves the state-of-the-art performance with higher computing and time efficiency3.
+
+Algorithm 1 Joint Training of Target Network and Augmentation Policy Network
+
+Initialization: target network $\mathcal { F } ( \cdot , w )$ , augmentation policy network $\boldsymbol { \mathcal { A } } ( \cdot , \pmb { \theta } )$ Input: input examples $_ { \textbf { \em x } }$ , corresponding labels $\textbf {  { y } }$
+
+1: for $1 \leq e \leq$ epochs do   
+2: Initialize $\widehat { \mathcal { L } } _ { m } = 0 , \forall m \in \{ 1 , 2 , \cdots , M \}$ ;   
+3: Generate $M$ policies with the probabilities $\{ p _ { 1 } , p _ { 2 } , \cdots , p _ { M } \}$ ;   
+4: for $1 \leq t \leq T$ do   
+5: Augment each batch data with $M$ generated policies, respectively;   
+6: Update $w _ { e , t + 1 }$ according to Equation 4;   
+7: Update ${ \widehat { \mathcal { L } } } _ { m }$ through moving average, $\forall m \in \{ 1 , 2 , \cdot \cdot \cdot , M \}$ ;   
+8: Collect $\{ \widehat { \mathcal { L } } _ { 1 } , \widehat { \mathcal { L } } _ { 2 } , \cdots , \widehat { \mathcal { L } } _ { M } \}$ ;   
+9: Normalize ${ \widehat { \mathcal { L } } } _ { m }$ among $M$ instances as $\widetilde { \mathcal { L } } _ { m } , \forall m \in \{ 1 , 2 , \cdots , M \}$ ;   
+10: Update $\pmb { \theta } _ { e + 1 }$ via Equation 9;   
+11: Output $w ^ { \ast } , \theta ^ { \ast }$
+
+# 4.1 EXPERIMENT SETTINGS
+
+The RNN controller is implemented as a one-layer LSTM (Hochreiter & Schmidhuber, 1997). We set the hidden size to 100, and the embedding size to 32. We use Adam optimizer (Kingma & Ba, 2015) with a initial learning rate 0.00035 to train the controller. To avoid unexpected rapid convergence, an entropy penalty of a weight of 0.00001 is applied. All the reported results are the mean of five runs with different initializations.
+
+# 4.2 EXPERIMENTS ON CIFAR-10 AND CIFAR-100
+
+CIFAR-10 dataset (Krizhevsky & Hinton, 2009) has totally 60000 images. The training and test sets have 50000 and 10000 images, respectively. Each image in size of $3 2 \times 3 2$ belongs to one of 10 classes. We evaluate our proposed method with the following models: Wide-ResNet-28- 10 (Zagoruyko & Komodakis, 2016), Shake-Shake $( 2 6 ~ 2 \mathrm { x } 3 2 \mathrm { d } )$ (Gastaldi, 2017), Shake-Shake (26 $2 \mathrm { x } 9 6 \mathrm { d } )$ (Gastaldi, 2017), Shake-Shake $( 2 6 2 \mathrm { x } 1 1 2 \mathrm { d } )$ (Gastaldi, 2017), PyramidNet+ShakeDrop (Han et al., 2017; Yamada et al., 2018). All the models are trained on the full training set.
+
+Training details: The Baseline is trained with the standard data augmentation, namely, randomly cropping a part of $3 2 \times 3 2$ from the padded image and horizontally flipping it with a probability of 0.5. The Cutout (Devries & Taylor, 2017) randomly select a $1 6 \times 1 6$ patch of each image, and then set the pixels of the selected patch to zeros. For our method, the searched policy is applied in addition to standard data augmentation and Cutout. For each image in the training process, standard data augmentation, the searched policy and Cutout are applied in sequence. For Wide-ResNet-28- 10, the step learning rate (LR) schedule is adopted. The cosine LR schedule is adopted for the other models. More details about model hyperparameters are supplied in A.1.
+
+Choice of $M$ : To choose the optimal $M$ , we select Wide-ResNet-28-10 as a target network, and evaluate the performance of our proposed method verse different $M$ , where $M \in \{ 2 , 4 , 8 , 1 6 , 3 2 \}$ . From Figure 5, we can observe that the test accuracy of the model improves rapidly with the increase of $M$ up to 8. The further increase of $M$ does not bring a significant improvement. Therefore, to balance the performance and the computing cost, $M$ is set to 8 in all the following experiments.
+
+CIFAR-10 results: In Table 1, we report the test error of these models on CIFAR-10. For all of these models, our proposed method can achieve better performance compared to previous methods. We achieve $0 . 7 8 \%$ and $0 . 6 8 \%$ improvement on Wide-ResNet-28-10 compared to AutoAugment and PBA, respectively. We achieve a top-1 test error of $1 . 3 6 \%$ with PyramidNet $^ +$ ShakeDrop, which is $0 . 1 \%$ better than the current state-of-the-art reported in Ho et al. (2019). As shown in Figure 6(a) and 6(b),we further visualize the probability distribution of the parameters of the augmentation policies learned with PyramidNet+ShakeDrop on CIFAR-10 over time. From Figure 6(a), we can find that the percentages of some operations, such as TranslateY, Rotate, Posterize, and SampleParing, gradually increase along with the training process. Meanwhile, more geometric transformations, such as TranslateX, TranslateY, and Rotate, are picked in the sampled augmentation policies, which is different from color-focused AutoAugment (Cubuk et al., 2019) on CIFAR-10. Figure 6(b) shows that large magnitudes gain higher percentages during training. However, at the tail of training, low magnitudes remain considerable percentages. This indicates that our method does not simply learn the transformations with the extremes of the allowed magnitudes to spoil the target network.
+
+![](images/1d9bd1c440b329d4cde0cd4933e8cd51662c730a2c81bacfeed27c2444ff1516.jpg)  
+Figure 4: The Comparison of normalized performance between AutoAugment and our method. Please refer to the following tables for more details.
+
+![](images/8f0622955a06ab6ba860d80c3c02ae266fb49a0c8467d420de114247a0cfe754.jpg)  
+Figure 5: The Top-1 test accuracy of WideResNet-28-10 on CIFAR-10 verse different $M$ , where $M \in \{ 2 , 4 , 8 , 1 6 , 3 2 \}$ .
+
+![](images/969c5da3cca5ba7fe0f9f8865ef328f9131f97876658c78dfb77dd5e89fdd3d5.jpg)  
+Figure 6: Probability distribution of the parameters in the learned augmentation policies on CIFAR10 over time. The number in (b) represents the magnitude of one operation. Larger number stands for more dramatic image transformations. The probability distribution of each parameter is the mean of each five epochs.
+
+CIFAR-100 results: We also evaluate our proposed method on CIFAR-100, as shown in Table 2.   
+As we can observe from the table, we also achieve the state-of-the-art performance on this dataset.
+
+Table 1: Top-1 test error $( \% )$ on CIFAR-10. We replicate the results of Baseline, Cutout and AutoAugment methods from Cubuk et al. (2019), and the results of PBA from Ho et al. (2019) in all of our experiments.   
+
+<table><tr><td>Model</td><td>Baseline</td><td>Cutout</td><td>AutoAugment</td><td>PBA</td><td>Our Method</td></tr><tr><td>Wide-ResNet-28-10</td><td>3.87</td><td>3.08</td><td>2.68</td><td>2.58</td><td>1.90±0.15</td></tr><tr><td>Shake-Shake (26 2x32d)</td><td>3.55</td><td>3.02</td><td>2.47</td><td>2.54</td><td>2.36±0.10</td></tr><tr><td>Shake-Shake (26 2x96d)</td><td>2.86</td><td>2.56</td><td>1.99</td><td>2.03</td><td>1.85±0.12</td></tr><tr><td>Shake-Shake (26 2x112d)</td><td>2.82</td><td>2.57</td><td>1.89</td><td>2.03</td><td>1.78±0.05</td></tr><tr><td>PyramidNet+ShakeDrop</td><td>2.67</td><td>2.31</td><td>1.48</td><td>1.46</td><td>1.36±0.06</td></tr></table>
+
+# 4.3 EXPERIMENTS ON IMAGENET
+
+As a great challenge in image recognition, ImageNet dataset (Deng et al., 2009) has about 1.2 million training images and 50000 validation images with 1000 classes. In this section, we directly search the augmentation policy on the full training set and train ResNet-50 (He et al., 2016), ResNet-50-D (He et al., 2018) and ResNet-200 (He et al., 2016) from scratch.
+
+Table 2: Top-1 test error $( \% )$ on CIFAR-100.   
+
+<table><tr><td>Model</td><td>Baseline</td><td>Cutout</td><td> AutoAugment</td><td>PBA</td><td>Our Method</td></tr><tr><td>Wide-ResNet-28-10</td><td>18.80</td><td>18.41</td><td>17.09</td><td>16.73</td><td>15.49±0.18</td></tr><tr><td>Shake-Shake (26 2x96d)</td><td>17.05</td><td>16.00</td><td>14.28</td><td>15.31</td><td>14.10±0.15</td></tr><tr><td>PyramidNet+ShakeDrop</td><td>13.99</td><td>12.19</td><td>10.67</td><td>10.94</td><td>10.42±0.20</td></tr></table>
+
+Training details: For the baseline augmentation, we randomly resize and crop each input image to a size of $2 2 4 \times 2 2 4$ , and then horizontally flip it with a probability of 0.5. For AutoAugment (Cubuk et al., 2019) and our method, the baseline augmentation and the augmentation policy are both used for each image. The cosine LR schedule is adopted in the training process. The model hyperparameters on ImageNet is also detailed in A.1.
+
+ImageNet results: The performance of our proposed method on ImageNet is presented in Table 3. It can be observed that we achieve a top-1 accuracy $7 9 . 4 0 \%$ on ResNet-50 without extra data. To the best of our knowledge, this is the highest top-1 accuracy for ResNet-50 learned on ImageNet. Besides, we only replace the ResNet-50 architecture with ResNet-50-D, and achieve a consistent improvement with a top-1 accuracy of $8 0 . 0 0 \%$ .
+
+Table 3: Top-1 / Top-5 test error $( \% )$ on ImageNet. Note that the result of ResNet-50-D is achieved only through substituting the architecture.   
+
+<table><tr><td>Model</td><td>Baseline</td><td>AutoAugment</td><td>PBA</td><td>Our Method</td></tr><tr><td>ResNet-50</td><td>23.69 / 6.92</td><td>22.37 /6.18</td><td>1</td><td>20.60±0.15 /5.53±0.05</td></tr><tr><td>ResNet-50-D</td><td>22.84 / 6.48</td><td>1</td><td></td><td>20.00±0.12/5.25±0.03</td></tr><tr><td>ResNet-200</td><td>21.52 / 5.85</td><td>20.00 /4.90</td><td>1</td><td>18.68±0.18 /4.70±0.05</td></tr></table>
+
+# 4.4 ABLATION STUDY
+
+To check the effect of each component in our proposed method, we report the test error of ResNet-50 on ImageNet the following augmentation methods in Table 4.
+
+• Baseline: Training regularly with the standard data augmentation and step LR schedule.   
+• Fixed: Augmenting all the instances of each batch with the standard data augmentation fixed throughout the entire training process. Random: Augmenting all the instances of each batch with randomly and dynamically generated policies. Ours: Augmenting all the instances of each batch with adversarial policies sampled by the policy network along with the training process.
+
+From the table, we can find that Fixed can achieve $0 . 9 9 \%$ error reduction compared to Baseline. This shows that a large-batch training with multiple augmented instances of each mini-batch can indeed improve the generalization of the model, which is consistent with the conclusion presented in Hoffer et al. (2019). In addition, the test error of Random is $1 . 0 2 \%$ better than Fixed. This indicates that augmenting batch with randomly generated policies can reduce overfitting in a certain extent. Furthermore, our method achieves the best test error of $2 0 . 6 0 \%$ through augmenting samples with adversarial policies. From the result, we can conclude that these policies generated by the policy network are more adaptive to the training process, and make the target network have to learn more robust features.
+
+# 4.5 COMPUTING COST AND TIME OVERHEAD
+
+Computing Cost: The computation in target network training is reused for policy evaluation. This makes the computing cost in policy search become negligible. Although there exists an increase of computing cost in target network training, the total computing cost in training one target network with augmentation policies is quite small compared to prior work.
+
+Time Overhead: Since we just train one target network with a large batch distributedly and simultaneously, the time overhead of the large-batch training is equal to the regular training. Meanwhile, the joint optimization of target network training and augmentation policy search dispenses with the process of offline policy search and the retraining of a target network, which leads to a extreme time overhead reduction.
+
+Table 4: Top-1 test error $( \% )$ of ResNet-50 with different augmentation methods on ImageNet.   
+
+<table><tr><td>Method</td><td>Aug. Policy</td><td>Enlarge Batch</td><td>LR Schedule</td><td>Test Error</td></tr><tr><td>Baseline</td><td>standard</td><td>M=1</td><td>step</td><td>23.69</td></tr><tr><td>Fixed</td><td>standard</td><td>M=8</td><td>cosine</td><td>22.70</td></tr><tr><td>Random</td><td>random</td><td>M=8</td><td>cosine</td><td>21.68</td></tr><tr><td>Ours</td><td>adversarial</td><td>M=8</td><td>cosine</td><td>20.60</td></tr></table>
+
+In Table 5, we take the training of ResNet-50 on ImageNet as an example to compare the computing cost and time overhead of our method and AutoAugment. From the table, we can find that our method is $1 2 \times$ less computing cost and $1 1 \times$ shorter time overhead than AutoAugment.
+
+Table 5: The comparison of computing cost (GPU hours) and time overhead (days) in training ResNet-50 on ImageNet between AutoAugment and our method. The computing cost and time overhead are estimated on 64 NVIDIA Tesla V100s.   
+
+<table><tr><td rowspan="2">Method</td><td colspan="3">Computing Cost</td><td colspan="3">Time Overhead</td></tr><tr><td>Searching</td><td>Training</td><td>Total</td><td>Searching</td><td>Training</td><td>Total</td></tr><tr><td>AutoAugment</td><td>15000</td><td>160</td><td>15160</td><td>10</td><td>1</td><td>11</td></tr><tr><td>Our Method</td><td>~0</td><td>1280</td><td>1280</td><td>~0</td><td>1</td><td>1</td></tr></table>
+
+# 4.6 TRANSFERABILITY ACROSS DATASETS AND ARCHITECTURES
+
+To further show the higher efficiency of our method, the transferability of the learned augmentation policies is evaluated in this section. We first take a snapshot of the adversarial training process of ResNet-50 on ImageNet, and then directly use the learned dynamic augmentation policies to regularly train the following models: Wide-ResNet-28-10 on CIFAR-10/100, ResNet-50-D on ImageNet and ResNet200 on ImageNet. Table 6 presents the experimental results of the transferability. From the table, we can find that a competitive performance can be still achieved through direct policy transfer. This indicates that the learned augmentation policies transfer well across datasets and architectures. However, compared to the proposed method, the policy transfer results in an obvious performance degradation, especially the transfer across datasets.
+
+Table 6: Top-1 test error $( \% )$ of the transfer of the augmentation policies learned with ResNet-50 on ImageNet.   
+
+<table><tr><td>Method</td><td>Dataset</td><td>AutoAugment</td><td>Our Method</td><td>Policy Transfer</td></tr><tr><td>Wide-ResNet-28-10</td><td>CIFAR-10</td><td>2.68</td><td>1.90</td><td>2.45±0.13</td></tr><tr><td>Wide-ResNet-28-10</td><td>CIFAR-100</td><td>17.09</td><td>15.49</td><td>16.48±0.15</td></tr><tr><td>ResNet-50-D</td><td>ImageNet</td><td>1</td><td>20.00</td><td>20.20±0.05</td></tr><tr><td>ResNet-200</td><td>ImageNet</td><td>20.00</td><td>18.68</td><td>19.05±0.10</td></tr></table>
+
+# 5 CONCLUSION
+
+In this paper, we introduce the idea of adversarial learning into automatic data augmentation. The policy network tries to combat the overfitting of the target network through generating adversarial policies with the training process. To oppose this, robust features are learned in the target network, which leads to a significant performance improvement. Meanwhile, the augmentation policy search is performed along with the training of a target network, and the computation in network training is reused for policy evaluation, which can extremely reduce the search cost and make our method more computing-efficient.
+
+# REFERENCES
+
+Antreas Antoniou, Amos J. Storkey, and Harrison Edwards. Data augmentation generative adversarial networks. ICLR, 2017.
+
+Ekin D. Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V. Le. Autoaugment: ´ Learning augmentation policies from data. CVPR, 2019.
+
+Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. CVPR, 2009.
+
+Terrance Devries and Graham W. Taylor. Improved regularization of convolutional neural networks with cutout. CoRR, abs/1708.04552, 2017.
+
+Maayan Frid-Adar, Eyal Klang, Michal Amitai, Jacob Goldberger, and Hayit Greenspan. Synthetic data augmentation using GAN for improved liver lesion classification. IEEE International Symposium on Biomedical Imaging (ISBI), 2018.
+
+Xavier Gastaldi. Shake-shake regularization. CoRR, abs/1705.07485, 2017.
+
+Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. NIPS, 2014.
+
+Minghao Guo, Zhao Zhong, Wei Wu, Dahua Lin, and Junjie Yan. IRLAS: inverse reinforcement learning for architecture search. CoRR, abs/1812.05285, 2018.
+
+Swaminathan Gurumurthy, Ravi Kiran Sarvadevabhatla, and Venkatesh Babu Radhakrishnan. Deligan : Generative adversarial networks for diverse and limited data. CVPR, 2017.
+
+Dongyoon Han, Jiwhan Kim, and Junmo Kim. Deep pyramidal residual networks. CVPR, 2017.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016.
+
+Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. CoRR, abs/1812.01187, 2018.
+
+Daniel Ho, Eric Liang, Ion Stoica, Pieter Abbeel, and Xi Chen. Population based augmentation: Efficient learning of augmentation policy schedules. ICML, 2019.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997.
+
+Elad Hoffer, Tal Ben-Nun, Itay Hubara, Niv Giladi, Torsten Hoefler, and Daniel Soudry. Augment your batch: better training with larger batches. CoRR, abs/1901.09335, 2019.
+
+Hiroshi Inoue. Data augmentation by pairing samples for images classification. CoRR, abs/1801.02929, 2018.
+
+Max Jaderberg, Valentin Dalibard, Simon Osindero, Wojciech M. Czarnecki, Jeff Donahue, Ali Razavi, Oriol Vinyals, Tim Green, Iain Dunning, Karen Simonyan, Chrisantha Fernando, and Koray Kavukcuoglu. Population based training of neural networks. CoRR, abs/1711.09846, 2017.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.
+
+Alex Krizhevsky and Geoffrey E. Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. NIPS, 2012.
+
+Joseph Lemley, Shabab Bazrafkan, and Peter Corcoran. Smart augmentation - learning an optimal data augmentation strategy. CoRR, abs/1703.08383, 2017.
+
+Chen Lin, Minghao Guo, Chuming Li, Wei Wu, Dahua Lin, Wanli Ouyang, and Junjie Yan. Online hyper-parameter learning for auto-augmentation strategy. CoRR, abs/1905.07373, 2019.
+
+Xi Peng, Zhiqiang Tang, Fei Yang, Rogerio Schmidt Feris, and Dimitris N. Metaxas. Jointly op- ´ timize data augmentation and network training: Adversarial data augmentation in human pose estimation. CVPR, 2018.
+
+Luis Perez and Jason Wang. The effectiveness of data augmentation in image classification using deep learning. CoRR, abs/1712.04621, 2017.
+
+Julian Salazar, Davis Liang, Zhiheng Huang, and Zachary C. Lipton. Invariant representation learning for robust deep networks. NeurIPS Workshop, 2018.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CVPR, 2015.
+
+Toan Tran, Trung Pham, Gustavo Carneiro, Lyle J. Palmer, and Ian D. Reid. A bayesian data augmentation approach for learning deep models. NIPS, 2017.
+
+Li Wan, Matthew Zeiler, Sixin Zhang, Yann LeCun, and Rob Fergus. Regularization of neural networks using dropconnect. ICML, 2013.
+
+Xiaolong Wang, Abhinav Shrivastava, and Abhinav Gupta. A-fast-rcnn: Hard positive generation via adversary for object detection. CVPR, 2017.
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 1992.
+
+Yoshihiro Yamada, Masakazu Iwamura, and Koichi Kise. Shakedrop regularization. CoRR, abs/1802.02375, 2018.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. British Machine Vision Conference, 2016.
+
+Zhao Zhong, Junjie Yan, and Cheng-Lin Liu. Practical network blocks design with Q-learning. CVPR, 2018a.
+
+Zhao Zhong, Zichen Yang, Boyang Deng, Junjie Yan, Wei Wu, Jing Shao, and Cheng-Lin Liu. BlockQNN: Efficient block-wise neural network architecture generation. CoRR, abs/1808.05584, 2018b.
+
+Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. ICLR, 2016.
+
+Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. CVPR, 2017.
+
+A APPENDIX
+
+# A.1 HYPERPARAMETERS
+
+We detail the model hyperparameters on CIFAR-10/CIFAR-100 and ImageNet in Table 7.
+
+Table 7: Model hyperparameters on CIFAR-10/CIFAR-100 and ImageNet. LR represents learning rate, and WD represents weight decay. We do not specifically tune these hyperparameters, and all of these are consistent with previous works, expect for the number of epochs.   
+
+<table><tr><td>Dataset</td><td>Model</td><td>Batch Size (N · M)</td><td>LR</td><td>WD</td><td>Epoch</td></tr><tr><td>CIFAR-10</td><td>Wide-ResNet-28-10</td><td>128·8</td><td>0.1</td><td>5e-4</td><td>200</td></tr><tr><td>CIFAR-10</td><td>Shake-Shake (26 2x32d)</td><td>128·8</td><td>0.2</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-10</td><td>Shake-Shake ( (262x96d)</td><td>128·8</td><td>0.2</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-10</td><td>Shake-Shake (26 2x112d)</td><td>128·8</td><td>0.2</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-10</td><td>PyramidNet+ShakeDrop</td><td>128·8</td><td>0.1</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-100</td><td>Wide-ResNet-28-10</td><td>128·8</td><td>0.1</td><td>5e-4</td><td>200</td></tr><tr><td>CIFAR-100</td><td>Shake-Shake (26 2x96d)</td><td>128·8</td><td>0.1</td><td>5e-4</td><td>1200</td></tr><tr><td>CIFAR-100</td><td>PyramidNet+ShakeDrop</td><td>128·8</td><td>0.5</td><td>1e-4</td><td>1200</td></tr><tr><td>ImageNet</td><td>ResNet-50</td><td>2048·8</td><td>0.8</td><td>1e-4</td><td>120</td></tr><tr><td>ImageNet</td><td>ResNet-50-D</td><td>2048·8</td><td>0.8</td><td>1e-4</td><td>120</td></tr><tr><td>ImageNet</td><td>ResNet-200</td><td>2048·8</td><td>0.8</td><td>1e-4</td><td>120</td></tr></table>

parse/train/ByxdUySKvS/ByxdUySKvS_content_list.json

@@ -0,0 +1,1538 @@
+[
+    {
+        "type": "text",
+        "text": "ADVERSARIAL AUTOAUGMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            117,
+            553,
+            136
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Xinyu Zhang   \nHuawei   \nzhangxinyu10@huawei.com   \nQiang Wang   \nHuawei   \nwangqiang168@huawei.com   \nJian Zhang   \nHuawei   \nzhangjian157@huawei.com   \nZhao Zhong   \nHuawei   \nzorro.zhongzhao@huawei.com ",
+        "bbox": [
+            184,
+            162,
+            411,
+            204
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            460,
+            162,
+            687,
+            204
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            226,
+            411,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            460,
+            226,
+            717,
+            267
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            304,
+            544,
+            319
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Data augmentation (DA) has been widely utilized to improve generalization in training deep neural networks. Recently, human-designed data augmentation has been gradually replaced by automatically learned augmentation policy. Through finding the best policy in well-designed search space of data augmentation, AutoAugment (Cubuk et al., 2019) can significantly improve validation accuracy on image classification tasks. However, this approach is not computationally practical for large-scale problems. In this paper, we develop an adversarial method to arrive at a computationally-affordable solution called Adversarial AutoAugment, which can simultaneously optimize target related object and augmentation policy search loss. The augmentation policy network attempts to increase the training loss of a target network through generating adversarial augmentation policies, while the target network can learn more robust features from harder examples to improve the generalization. In contrast to prior work, we reuse the computation in target network training for policy evaluation, and dispense with the retraining of the target network. Compared to AutoAugment, this leads to about $1 2 \\times$ reduction in computing cost and $1 1 \\times$ shortening in time overhead on ImageNet. We show experimental results of our approach on CIFAR-10/CIFAR-100, ImageNet, and demonstrate significant performance improvements over state-of-the-art. On CIFAR-10, we achieve a top-1 test error of $1 . 3 6 \\%$ , which is the currently best performing single model. On ImageNet, we achieve a leading performance of top-1 accuracy $7 9 . 4 0 \\%$ on ResNet-50 and $8 0 . 0 0 \\%$ on ResNet-50-D without extra data. ",
+        "bbox": [
+            233,
+            335,
+            764,
+            627
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            655,
+            334,
+            671
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Massive amount of data have promoted the great success of deep learning in academia and industry. The performance of deep neural networks (DNNs) would be improved substantially when more supervised data is available or better data augmentation method is adapted. Data augmentation such as rotation, flipping, cropping, etc., is a powerful technique to increase the amount and diversity of data. Experiments show that the generalization of a neural network can be efficiently improved through manually designing data augmentation policies. However, this needs lots of knowledge of human expert, and sometimes shows the weak transferability across different tasks and datasets in practical applications. Inspired by neural architecture search (NAS)(Zoph & Le, 2016; Zoph et al., 2017; Zhong et al., 2018a;b; Guo et al., 2018), a reinforcement learning (RL) (Williams, 1992) method called AutoAugment is proposed by Cubuk et al. (2019), which can automatically learn the augmentation policy from data and provide an exciting performance improvement on image classification tasks. However, the computing cost is huge for training and evaluating thousands of sampled policies in the search process. Although proxy tasks, i.e., smaller models and reduced datasets, are taken to accelerate the searching process, tens of thousands of GPU-hours of consumption are still required. In addition, these data augmentation policies optimized on proxy tasks are not guaranteed to be optimal on the target task, and the fixed augmentation policy is also sub-optimal for the whole training process. ",
+        "bbox": [
+            174,
+            688,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/30303714f451b21eaee42acd79567fecfdfac2cdfb67ff8adc6f2486bb4f5ec4.jpg",
+        "image_caption": [
+            "Figure 1: The overview of our proposed method. We formulate it as a Min-Max game. The data of each batch is augmented by multiple pre-processing components with sampled policies $\\{ \\tau _ { 1 } , \\tau _ { 2 } , \\cdots , \\tau _ { M } \\}$ , respectively. Then, a target network is trained to minimize the loss of a large batch, which is formed by multiple augmented instances of the input batch. We extract the training losses of a target network corresponding to different augmentation policies as the reward signal. Finally, the augmentation policy network is trained with the guideline of the processed reward signal, and aims to maximize the training loss of the target network through generating adversarial policies. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            102,
+            730,
+            369
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose an efficient data augmentation method to address the problems mentioned above, which can directly search the best augmentation policy on the full dataset during training a target network, as shown in Figure 1. We first organize the network training and augmentation policy search in an adversarial and online manner. The augmentation policy is dynamically changed along with the training state of the target network, rather than fixed throughout the whole training process like normal AutoAugment (Cubuk et al., 2019). Due to reusing the computation in policy evaluation and dispensing with the retraining of the target network, the computing cost and time overhead are extremely reduced. Then, the augmentation policy network is taken as an adversary to explore the weakness of the target network. We augment the data of each min-batch with various adversarial policies in parallel, rather than the same data augmentation taken in batch augmentation (BA) (Hoffer et al., 2019). Then, several augmented instances of each mini-batch are formed into a large batch for target network learning. As an indicator of the hardness of augmentation policies, the training losses of the target network are used to guide the policy network to generate more aggressive and efficient policies based on REINFORCE algorithm (Williams, 1992). Through adversarial learning, we can train the target network more efficiently and robustly. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            694
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The contributions can be summarized as follows: ",
+        "bbox": [
+            176,
+            700,
+            495,
+            714
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Our method can directly learn augmentation policies on target tasks, i.e., target networks and full datasets, with a quite low computing cost and time overhead. The direct policy search avoids the performance degradation caused by the policy transfer from proxy tasks to target tasks.   \n• We propose an adversarial framework to jointly optimize target network training and augmentation policy search. The harder samples augmented by adversarial policies are constantly fed into the target network to promote robust feature learning. Hence, the generalization of the target network can be significantly improved.   \n• The experiment results show that our proposed method outperforms previous augmentation methods. For instance, we achieve a top-1 test error of $1 . 3 6 \\%$ with PyramidNet+ShakeDrop (Yamada et al., 2018) on CIFAR-10, which is the state-of-the-art performance. On ImageNet, we improve the top-1 accuracy of ResNet-50 (He et al., 2016) from $7 6 . 3 \\%$ to $7 9 . 4 \\%$ without extra data, which is even $1 . 7 7 \\%$ better than AutoAugment (Cubuk et al., 2019). ",
+        "bbox": [
+            215,
+            720,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Common data augmentation, which can generate extra samples by some label-preserved transformations, is usually used to increase the size of datasets and improve the generalization of networks, such as on MINST, CIFAR-10 and ImageNet (Krizhevsky et al., 2012; Wan et al., 2013; Szegedy et al., 2015). However, human-designed augmentation policies are specified for different datasets. For example, flipping, the widely used transformation on CIFAR-10/CIFAR-100 and ImageNet, is not suitable for MINST, which will destroy the property of original samples. ",
+        "bbox": [
+            174,
+            132,
+            825,
+            217
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Hence, several works (Lemley et al., 2017; Cubuk et al., 2019; Lin et al., 2019; Ho et al., 2019) have attempted to automatically learn data augmentation policies. Lemley et al. (2017) propose a method called Smart Augmentation, which merges two or more samples of a class to improve the generalization of a target network. The result also indicates that an augmentation network can be learned when a target network is being training. Through well designing the search space of data augmentation policies, AutoAugment (Cubuk et al., 2019) takes a recurrent neural network (RNN) as a sample controller to find the best data augmentation policy for a selected dataset. To reduce the computing cost, the augmentation policy search is performed on proxy tasks. Population based augmentation (PBA) (Ho et al., 2019) replaces the fixed augmentation policy with a dynamic schedule of augmentation policy along with the training process, which is mostly related to our work. Inspired by population based training (PBT) (Jaderberg et al., 2017), the augmentation policy search problem in PBA is modeled as a process of hyperparameter schedule learning. However, the augmentation schedule learning is still performed on proxy tasks. The learned policy schedule should be manually adjusted when the training process of a target network is non-matched with proxy tasks. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            431
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another related topic is Generative Adversarial Networks (GANs) (Goodfellow et al., 2014), which has recently attracted lots of research attention due to its fascinating performance, and also been used to enlarge datasets through directly synthesizing new images (Tran et al., 2017; Perez & Wang, 2017; Antoniou et al., 2017; Gurumurthy et al., 2017; Frid-Adar et al., 2018). Although we formulate our proposed method as a Min-Max game, there exists an obvious difference with traditional GANs. We want to find the best augmentation policy to perform image transformation along with the training process, rather than synthesize new images. Peng et al. (2018) also take such an idea to optimize the training process of a target network in human pose estimation. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            550
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            282,
+            580
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present the implementation of Adversarial AutoAugment. First, the motivation for the adversarial relation between network learning and augmentation policy is discussed. Then, we introduce the search space with the dynamic augmentation policy. Finally, the joint framework for network training and augmentation policy search is presented in detail. ",
+        "bbox": [
+            176,
+            589,
+            823,
+            645
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 MOTIVATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            654,
+            313,
+            669
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Although some human-designed data augmentations have been used in the training of DNNs, such as randomly cropping and horizontally flipping on CIFAR-10/CIFAR-100 and ImageNet, limited randomness will make it very difficult to generate effective samples at the tail end of the training. To struggle with the problem, more randomness about image transformation is introduced into the search space of AutoAugment (Cubuk et al., 2019) (described in Section 3.2). However, the learned policy is fixed for the entire training process. All of possible instances of each example will be send to the target network repeatedly, which still results in an inevitable overfitting in a long-epoch training. This phenomenon indicates that the learned policy is not adaptive to the training process of a target network, especially found on proxy tasks. Hence, the dynamic and adversarial augmentation policy with the training process is considered as the crucial feature in our search space. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            819
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Another consideration is how to improve the efficiency of the policy search. In AutoAugment (Cubuk et al., 2019), to evaluate the performance of augmentation policies, a lot of child models should be trained from scratch nearly to convergence. The computation in training and evaluating the performance of different sampled policies can not be reused, which leads to huge waste of computation resources. In this paper, we propose a computing-efficient policy search framework through reusing prior computation in policy evaluation. Only one target network is used to evaluate the performance of different policies with the help of the training losses of corresponding augmented instances. The augmentation policy network is learned from the intermediate state of the target network, which makes generated augmentation policies more aggressive and adaptive. On the contrary, to combat harder examples augmented by adversarial policies, the target network has to learn more robust features, which makes the training more efficiently. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/cf1281f8bae28f7b31d6aab6d29d8044913d73f1d9a58a90985849e432656219.jpg",
+        "image_caption": [
+            "Figure 2: An example of dynamic augmentation policies learned with ResNet-50 on ImageNet. With the training process of the target network, harder augmentation policies are sampled to combat overfitting. Intuitively, more geometric transformations, such as TranslateX, ShearY and Rotate, are picked in our sampled policies, which is obviously different from AutoAugment (Cubuk et al., 2019) concentrating on color-based transformations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            269,
+            103,
+            728,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            512,
+            825,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 SEARCH SPACE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            587,
+            321,
+            601
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this paper, the basic structure of the search space of AutoAugment (Cubuk et al., 2019) is reserved. An augmentation policy is defined as that it is composed by 5 sub-policies, each sub-policy contains two image operations to be applied orderly, each operation has two corresponding parameters, i.e., the probability and magnitude of the operation. Finally, the 5 best policies are concatenated to form a single policy with 25 sub-policies. For each image in a mini-batch, only one sub-policy will be randomly selected to be applied. To compare with AutoAugment (Cubuk et al., 2019) conveniently, we just slightly modify the search space with removing the probability of each operation. This is because that we think the stochasticity of an operation with a probability requires a certain epochs to take effect, which will detain the feedback of the intermediate state of the target network. There are totally 16 image operations in our search space, including ShearX/Y, TranslateX/Y, Rotate, AutoContrast, Invert, Equalize, Solarize, Posterize, Contrast, Color, Brightness, Sharpness, Cutout (Devries & Taylor, 2017) and Sample Pairing (Inoue, 2018). The range of the magnitude is also discretized uniformly into 10 values. To guarantee the convergence during adversarial learning, the magnitude of all the operations are set in a moderate range.1 Besides, the randomness during the training process is introduced into our search space. Hence, the search space of the policy in each epoch has $| S | = ( 1 6 \\times 1 0 ) ^ { 1 0 } \\approx 1 . 1 \\times 1 0 ^ { 2 2 }$ possibilities. Considering the dynamic policy, the number of possible policies with the whole training process can be expressed as $| S | ^ { \\# e p o c h s }$ . An example of dynamically learning the augmentation policy along with the training process is shown in Figure 2. We observe that the magnitude (an indication of difficulty) gradually increases with the training process. ",
+        "bbox": [
+            173,
+            613,
+            825,
+            891
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 ADVERSARIAL LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            397,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this section, the adversarial framework of jointly optimizing network training and augmentation policy search is presented in detail. We use the augmentation policy network $\\boldsymbol { \\mathcal { A } } ( \\cdot , \\pmb { \\theta } )$ as an adversary, which attempts to increase the training loss of the target network $\\mathcal { F } ( \\cdot , w )$ through adversarial learning. The target network is trained by a large batch formed by multiple augmented instances of each batch to promote invariant learning (Salazar et al., 2018), and the losses of different augmentation policies applied on the same data are used to train the augmentation policy network by RL algorithm. ",
+        "bbox": [
+            173,
+            128,
+            825,
+            227
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Considering the target network $\\mathcal { F } ( \\cdot , w )$ with a loss function $\\mathcal { L } [ \\mathcal { F } ( \\pmb { x } , \\pmb { w } ) , \\pmb { y } ]$ , where each example is transformed by some random data augmentation $o ( \\cdot )$ , the learning process of the target network can be defined as the following minimization problem ",
+        "bbox": [
+            173,
+            233,
+            825,
+            276
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/357437841a8baa4fa9afe57c2203e6f99e1e22cebf9010ee0941a751ac3842af.jpg",
+        "text": "$$\n\\pmb { w } ^ { * } = \\underset { \\pmb { w } } { \\arg \\operatorname* { m i n } } \\ \\underset { \\pmb { x } \\sim \\Omega } { \\mathbb { E } } \\mathcal { L } [ \\mathcal { F } ( o ( \\pmb { x } ) , \\pmb { w } ) , \\pmb { y } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            282,
+            625,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\Omega$ is the training set, $_ { \\textbf { \\em x } }$ and $\\textbf {  { y } }$ are the input image and the corresponding label, respectively. The problem is usually solved by vanilla SGD with a learning rate $\\eta$ and batch size $N$ , and the training procedure for each batch can be expressed as ",
+        "bbox": [
+            174,
+            313,
+            825,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7faff2f8aad97c6f5a263204249682b43d9c780cd18be5222f7b9a8d73afeb5d.jpg",
+        "text": "$$\n\\pmb { w } _ { t + 1 } = \\pmb { w } _ { t } - \\eta \\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\nabla _ { \\pmb { w } } \\mathcal { L } [ \\mathcal { F } ( o ( x _ { n } ) , \\pmb { w } , y _ { n } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            362,
+            655,
+            406
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To improve the convergence performance of DNNs, more random and efficient data augmentation is performed under the help of the augmentation policy network. Hence, the minimization problem should be slightly modified as ",
+        "bbox": [
+            173,
+            411,
+            825,
+            454
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8079bec44737be130c48f9d62df760c081ece4d44dde85d73f5880512a4aa3a1.jpg",
+        "text": "$$\n\\pmb { w } ^ { * } = \\underset { \\pmb { w } } { \\arg \\operatorname* { m i n } } \\ \\underset { \\pmb { x } \\sim \\Omega } { \\mathbb { E } } \\ \\underset { \\pmb { \\mathcal { A } } ( \\cdot , \\pmb { \\theta } ) } { \\mathbb { E } } \\mathcal { L } [ \\mathcal { F } ( \\tau ( \\pmb { x } ) , \\pmb { w } ) , \\pmb { y } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            459,
+            653,
+            487
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\tau ( \\cdot )$ represents the augmentation policy generated by the network $\\boldsymbol { \\mathcal { A } } ( \\cdot , \\pmb { \\theta } )$ . Accordingly, the training rule can be rewritten as ",
+        "bbox": [
+            171,
+            493,
+            825,
+            522
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3f6c2b66da389f91cb63fc352188ac2f1e21fad261eccee4d496f485d8497008.jpg",
+        "text": "$$\n\\pmb { w } _ { t + 1 } = \\pmb { w } _ { t } - \\eta \\frac { 1 } { M \\cdot N } \\sum _ { m = 1 } ^ { M } \\sum _ { n = 1 } ^ { N } \\nabla _ { \\pmb { w } } \\mathcal { L } [ \\mathcal { F } ( \\tau _ { m } ( x _ { n } ) , \\pmb { w } ) , y _ { n } ] ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            527,
+            694,
+            573
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we introduce $M$ different instances of each input example augmented by adversarial policies $\\{ \\tau _ { 1 } , \\tau _ { 2 } , \\cdots , \\tau _ { M } \\}$ . For convenience, we denote the training loss of a mini-batch corresponding to the augmentation policy $\\tau _ { m }$ as ",
+        "bbox": [
+            173,
+            578,
+            823,
+            621
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ad5ce4403f7216948077f7576c678356d0e67d7debf75ab5897c632920a41053.jpg",
+        "text": "$$\n\\mathcal { L } _ { m } = \\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\mathcal { L } [ \\mathcal { F } ( \\tau _ { m } ( x _ { n } ) , \\pmb { w } ) , y _ { n } ] .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            627,
+            620,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Hence, we have an equivalent form of Equation 4 ",
+        "bbox": [
+            173,
+            675,
+            500,
+            690
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bb4c92c686635270ad2964c689792a678bc42b36ac081a645445e349d60251b0.jpg",
+        "text": "$$\n\\pmb { w } _ { t + 1 } = \\pmb { w } _ { t } - \\eta \\frac { 1 } { M } \\sum _ { m = 1 } ^ { M } \\nabla _ { \\pmb { w } } \\mathcal { L } _ { m } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            696,
+            607,
+            741
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that the training procedure can be regarded as a larger $N \\cdot M$ batch training or an average over $M$ instances of gradient computation without changing the learning rate, which will lead to a reduction of gradient variance and a faster convergence of the target network Hoffer et al. (2019). However, overfitting will also come. To overcome the problem, the augmentation policy network is designed to increase the training loss of the target network with harder augmentation policies. Therefore, we can mathematically express the object as the following maximization problem ",
+        "bbox": [
+            173,
+            744,
+            826,
+            829
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/107b151f7b522f76c993d3bbdfae27d7ce8897abeaefdc3b4bea230fc92817c0.jpg",
+        "text": "$$\n\\begin{array} { c } { \\pmb { \\theta } ^ { * } = \\underset { \\pmb { \\theta } } { \\arg \\operatorname* { m a x } } J ( \\pmb { \\theta } ) , } \\\\ { \\mathrm { w h e r e } ~ J ( \\pmb { \\theta } ) = \\underset { \\pmb { x } \\sim \\Omega } { \\mathbb { E } } ~ \\underset { \\pmb { \\mathbb { E } } ( \\cdot , \\pmb { \\theta } ) } { \\mathbb { E } } \\mathcal { L } [ \\mathcal { F } ( \\tau ( \\pmb { x } ) , \\pmb { w } ) , \\pmb { y } ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            341,
+            834,
+            655,
+            890
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Similar to AutoAugment (Cubuk et al., 2019), the augmentation policy network is also implemented as a RNN shown in Figure 3. At each time step of the RNN controller, the softmax layer will predict an action corresponding to a discrete parameter of a sub-policy, and then an embedding of the predicted action will be fed into the next time step. In our experiments, the RNN controller will predict 20 discrete parameters to form a whole policy. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/d2f4b35084c6e611d6139d1fbef94757f5d6b6d525d6edbd65d47563cffa3f4c.jpg",
+        "image_caption": [
+            "Figure 3: The basic architecture of the controller for generating a sub-policy, which consists of two operations with corresponding parameters, the type and magnitude of each operation. When a policy contains $Q$ sub-policies, the basic architecture will be repeated $Q$ times. Following the setting of AutoAugment (Cubuk et al., 2019), the number of sub-policies $Q$ is set to 5 in this paper. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            240,
+            102,
+            759,
+            234
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            306,
+            825,
+            349
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "However, there has a severe problem in jointly optimizing target network training and augmentation policy search. This is because that non-differentiable augmentation operations break gradient flow from the target network $\\mathcal { F }$ to the augmentation policy network $\\mathcal { A }$ (Wang et al., 2017; Peng et al., 2018). As an alternative approach, REINFORCE algorithm (Williams, 1992) is applied to optimize the augmentation policy network as ",
+        "bbox": [
+            174,
+            356,
+            823,
+            426
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0cd49c12d4aebfe70e605f93dd6deb419619fe0bd1e60dbd2c8f5cc69d4e9f2e.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\theta } J ( \\theta ) = \\nabla _ { \\theta } \\underset { x \\sim \\Omega \\tau \\sim A ( \\cdot , \\theta ) } { \\mathbb { E } } ~ \\underset { { A } ^ { ( \\cdot ) } } { \\mathbb { E } } ~ \\mathcal { L } [ \\mathcal { F } ( \\tau ( x ) , w ) , y ] } \\\\ & { \\approx \\displaystyle \\sum _ { m } \\mathcal { L } _ { m } \\nabla _ { \\theta } p _ { m } = \\sum _ { m } \\mathcal { L } _ { m } p _ { m } \\nabla _ { \\theta } \\log p _ { m } } \\\\ & { ~ = \\underset { { \\tau \\sim A ( \\cdot , \\theta ) } } { \\mathbb { E } } ~ \\mathcal { L } _ { m } \\nabla _ { \\theta } \\log p _ { m } } \\\\ & { ~ \\approx \\frac { 1 } { M } \\displaystyle \\sum _ { m = 1 } ^ { M } \\mathcal { L } _ { m } \\nabla _ { \\theta } \\log p _ { m } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            433,
+            665,
+            569
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where $p _ { m }$ represents the probability of the policy $\\tau _ { m }$ . To reduce the variance of gradient $\\nabla _ { \\pmb { \\theta } } J ( \\pmb { \\theta } )$ , we replace the training loss of a mini-batch ${ \\mathcal { L } } _ { m }$ with ${ \\widehat { \\mathcal { L } } } _ { m }$ a moving average over a certain minibatches2, and then normalize it among $M$ instances as ${ \\widetilde { \\mathcal { L } } } _ { m }$ . Hence, the training procedure of the augmentation policy network can be expressed as ",
+        "bbox": [
+            173,
+            575,
+            826,
+            637
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/95ede88d418cd5eb2dfdb765c787784d9b7309625eafd669d96747e2ab95096d.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\pmb { \\theta } } J ( \\pmb { \\theta } ) \\approx \\cfrac { 1 } { M } \\displaystyle \\sum _ { m = 1 } ^ { M } \\widetilde { \\mathcal { L } } _ { m } \\nabla _ { \\pmb { \\theta } } \\log p _ { m } , } \\\\ & { \\theta _ { e + 1 } = \\theta _ { e } + \\beta \\displaystyle \\frac { 1 } { M } \\displaystyle \\sum _ { m = 1 } ^ { M } \\widetilde { \\mathcal { L } } _ { m } \\nabla _ { \\pmb { \\theta } } \\log p _ { m } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            645,
+            625,
+            734
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The adversarial learning of target network training and augmentation policy search is summarized as Algorithm 1. ",
+        "bbox": [
+            173,
+            741,
+            825,
+            770
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            459,
+            804
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we first reveal the details of experiment settings. Then, we evaluate our proposed method on CIFAR-10/CIFAR-100, ImageNet, and compare it with previous methods. Results in Figure 4 show our method achieves the state-of-the-art performance with higher computing and time efficiency3. ",
+        "bbox": [
+            173,
+            813,
+            825,
+            869
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Joint Training of Target Network and Augmentation Policy Network ",
+        "bbox": [
+            173,
+            102,
+            710,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Initialization: target network $\\mathcal { F } ( \\cdot , w )$ , augmentation policy network $\\boldsymbol { \\mathcal { A } } ( \\cdot , \\pmb { \\theta } )$ Input: input examples $_ { \\textbf { \\em x } }$ , corresponding labels $\\textbf {  { y } }$ ",
+        "bbox": [
+            173,
+            121,
+            676,
+            150
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1: for $1 \\leq e \\leq$ epochs do   \n2: Initialize $\\widehat { \\mathcal { L } } _ { m } = 0 , \\forall m \\in \\{ 1 , 2 , \\cdots , M \\}$ ;   \n3: Generate $M$ policies with the probabilities $\\{ p _ { 1 } , p _ { 2 } , \\cdots , p _ { M } \\}$ ;   \n4: for $1 \\leq t \\leq T$ do   \n5: Augment each batch data with $M$ generated policies, respectively;   \n6: Update $w _ { e , t + 1 }$ according to Equation 4;   \n7: Update ${ \\widehat { \\mathcal { L } } } _ { m }$ through moving average, $\\forall m \\in \\{ 1 , 2 , \\cdot \\cdot \\cdot , M \\}$ ;   \n8: Collect $\\{ \\widehat { \\mathcal { L } } _ { 1 } , \\widehat { \\mathcal { L } } _ { 2 } , \\cdots , \\widehat { \\mathcal { L } } _ { M } \\}$ ;   \n9: Normalize ${ \\widehat { \\mathcal { L } } } _ { m }$ among $M$ instances as $\\widetilde { \\mathcal { L } } _ { m } , \\forall m \\in \\{ 1 , 2 , \\cdots , M \\}$ ;   \n10: Update $\\pmb { \\theta } _ { e + 1 }$ via Equation 9;   \n11: Output $w ^ { \\ast } , \\theta ^ { \\ast }$ ",
+        "bbox": [
+            176,
+            151,
+            684,
+            321
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 EXPERIMENT SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            352,
+            382,
+            367
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The RNN controller is implemented as a one-layer LSTM (Hochreiter & Schmidhuber, 1997). We set the hidden size to 100, and the embedding size to 32. We use Adam optimizer (Kingma & Ba, 2015) with a initial learning rate 0.00035 to train the controller. To avoid unexpected rapid convergence, an entropy penalty of a weight of 0.00001 is applied. All the reported results are the mean of five runs with different initializations. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            449
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTS ON CIFAR-10 AND CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            462,
+            542,
+            476
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 dataset (Krizhevsky & Hinton, 2009) has totally 60000 images. The training and test sets have 50000 and 10000 images, respectively. Each image in size of $3 2 \\times 3 2$ belongs to one of 10 classes. We evaluate our proposed method with the following models: Wide-ResNet-28- 10 (Zagoruyko & Komodakis, 2016), Shake-Shake $( 2 6 ~ 2 \\mathrm { x } 3 2 \\mathrm { d } )$ (Gastaldi, 2017), Shake-Shake (26 $2 \\mathrm { x } 9 6 \\mathrm { d } )$ (Gastaldi, 2017), Shake-Shake $( 2 6 2 \\mathrm { x } 1 1 2 \\mathrm { d } )$ (Gastaldi, 2017), PyramidNet+ShakeDrop (Han et al., 2017; Yamada et al., 2018). All the models are trained on the full training set. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            569
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training details: The Baseline is trained with the standard data augmentation, namely, randomly cropping a part of $3 2 \\times 3 2$ from the padded image and horizontally flipping it with a probability of 0.5. The Cutout (Devries & Taylor, 2017) randomly select a $1 6 \\times 1 6$ patch of each image, and then set the pixels of the selected patch to zeros. For our method, the searched policy is applied in addition to standard data augmentation and Cutout. For each image in the training process, standard data augmentation, the searched policy and Cutout are applied in sequence. For Wide-ResNet-28- 10, the step learning rate (LR) schedule is adopted. The cosine LR schedule is adopted for the other models. More details about model hyperparameters are supplied in A.1. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Choice of $M$ : To choose the optimal $M$ , we select Wide-ResNet-28-10 as a target network, and evaluate the performance of our proposed method verse different $M$ , where $M \\in \\{ 2 , 4 , 8 , 1 6 , 3 2 \\}$ . From Figure 5, we can observe that the test accuracy of the model improves rapidly with the increase of $M$ up to 8. The further increase of $M$ does not bring a significant improvement. Therefore, to balance the performance and the computing cost, $M$ is set to 8 in all the following experiments. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            763
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10 results: In Table 1, we report the test error of these models on CIFAR-10. For all of these models, our proposed method can achieve better performance compared to previous methods. We achieve $0 . 7 8 \\%$ and $0 . 6 8 \\%$ improvement on Wide-ResNet-28-10 compared to AutoAugment and PBA, respectively. We achieve a top-1 test error of $1 . 3 6 \\%$ with PyramidNet $^ +$ ShakeDrop, which is $0 . 1 \\%$ better than the current state-of-the-art reported in Ho et al. (2019). As shown in Figure 6(a) and 6(b),we further visualize the probability distribution of the parameters of the augmentation policies learned with PyramidNet+ShakeDrop on CIFAR-10 over time. From Figure 6(a), we can find that the percentages of some operations, such as TranslateY, Rotate, Posterize, and SampleParing, gradually increase along with the training process. Meanwhile, more geometric transformations, such as TranslateX, TranslateY, and Rotate, are picked in the sampled augmentation policies, which is different from color-focused AutoAugment (Cubuk et al., 2019) on CIFAR-10. Figure 6(b) shows that large magnitudes gain higher percentages during training. However, at the tail of training, low magnitudes remain considerable percentages. This indicates that our method does not simply learn the transformations with the extremes of the allowed magnitudes to spoil the target network. ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d9bd1c440b329d4cde0cd4933e8cd51662c730a2c81bacfeed27c2444ff1516.jpg",
+        "image_caption": [
+            "Figure 4: The Comparison of normalized performance between AutoAugment and our method. Please refer to the following tables for more details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            104,
+            473,
+            272
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/8f0622955a06ab6ba860d80c3c02ae266fb49a0c8467d420de114247a0cfe754.jpg",
+        "image_caption": [
+            "Figure 5: The Top-1 test accuracy of WideResNet-28-10 on CIFAR-10 verse different $M$ , where $M \\in \\{ 2 , 4 , 8 , 1 6 , 3 2 \\}$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            542,
+            112,
+            794,
+            273
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/969c5da3cca5ba7fe0f9f8865ef328f9131f97876658c78dfb77dd5e89fdd3d5.jpg",
+        "image_caption": [
+            "Figure 6: Probability distribution of the parameters in the learned augmentation policies on CIFAR10 over time. The number in (b) represents the magnitude of one operation. Larger number stands for more dramatic image transformations. The probability distribution of each parameter is the mean of each five epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            347,
+            813,
+            530
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            595,
+            825,
+            637
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-100 results: We also evaluate our proposed method on CIFAR-100, as shown in Table 2.   \nAs we can observe from the table, we also achieve the state-of-the-art performance on this dataset. ",
+        "bbox": [
+            176,
+            645,
+            820,
+            674
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/d929706459bceab76309d542582ff87eb9b290a004d6adec648ac5702809b1fa.jpg",
+        "table_caption": [
+            "Table 1: Top-1 test error $( \\% )$ on CIFAR-10. We replicate the results of Baseline, Cutout and AutoAugment methods from Cubuk et al. (2019), and the results of PBA from Ho et al. (2019) in all of our experiments. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Baseline</td><td>Cutout</td><td>AutoAugment</td><td>PBA</td><td>Our Method</td></tr><tr><td>Wide-ResNet-28-10</td><td>3.87</td><td>3.08</td><td>2.68</td><td>2.58</td><td>1.90±0.15</td></tr><tr><td>Shake-Shake (26 2x32d)</td><td>3.55</td><td>3.02</td><td>2.47</td><td>2.54</td><td>2.36±0.10</td></tr><tr><td>Shake-Shake (26 2x96d)</td><td>2.86</td><td>2.56</td><td>1.99</td><td>2.03</td><td>1.85±0.12</td></tr><tr><td>Shake-Shake (26 2x112d)</td><td>2.82</td><td>2.57</td><td>1.89</td><td>2.03</td><td>1.78±0.05</td></tr><tr><td>PyramidNet+ShakeDrop</td><td>2.67</td><td>2.31</td><td>1.48</td><td>1.46</td><td>1.36±0.06</td></tr></table>",
+        "bbox": [
+            199,
+            731,
+            795,
+            832
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 EXPERIMENTS ON IMAGENET ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            847,
+            421,
+            862
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As a great challenge in image recognition, ImageNet dataset (Deng et al., 2009) has about 1.2 million training images and 50000 validation images with 1000 classes. In this section, we directly search the augmentation policy on the full training set and train ResNet-50 (He et al., 2016), ResNet-50-D (He et al., 2018) and ResNet-200 (He et al., 2016) from scratch. ",
+        "bbox": [
+            174,
+            868,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/1c93b5f77c1ed4a44c3eae869260059d2b4c4df4c9ddaf09ea86ef7706a1d1fc.jpg",
+        "table_caption": [
+            "Table 2: Top-1 test error $( \\% )$ on CIFAR-100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Baseline</td><td>Cutout</td><td> AutoAugment</td><td>PBA</td><td>Our Method</td></tr><tr><td>Wide-ResNet-28-10</td><td>18.80</td><td>18.41</td><td>17.09</td><td>16.73</td><td>15.49±0.18</td></tr><tr><td>Shake-Shake (26 2x96d)</td><td>17.05</td><td>16.00</td><td>14.28</td><td>15.31</td><td>14.10±0.15</td></tr><tr><td>PyramidNet+ShakeDrop</td><td>13.99</td><td>12.19</td><td>10.67</td><td>10.94</td><td>10.42±0.20</td></tr></table>",
+        "bbox": [
+            199,
+            116,
+            794,
+            189
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Training details: For the baseline augmentation, we randomly resize and crop each input image to a size of $2 2 4 \\times 2 2 4$ , and then horizontally flip it with a probability of 0.5. For AutoAugment (Cubuk et al., 2019) and our method, the baseline augmentation and the augmentation policy are both used for each image. The cosine LR schedule is adopted in the training process. The model hyperparameters on ImageNet is also detailed in A.1. ",
+        "bbox": [
+            174,
+            199,
+            825,
+            268
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ImageNet results: The performance of our proposed method on ImageNet is presented in Table 3. It can be observed that we achieve a top-1 accuracy $7 9 . 4 0 \\%$ on ResNet-50 without extra data. To the best of our knowledge, this is the highest top-1 accuracy for ResNet-50 learned on ImageNet. Besides, we only replace the ResNet-50 architecture with ResNet-50-D, and achieve a consistent improvement with a top-1 accuracy of $8 0 . 0 0 \\%$ . ",
+        "bbox": [
+            174,
+            275,
+            825,
+            344
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/c11394c053c797ac41deef027c8e6c75b7d63680580b038230cdbafd75d497b2.jpg",
+        "table_caption": [
+            "Table 3: Top-1 / Top-5 test error $( \\% )$ on ImageNet. Note that the result of ResNet-50-D is achieved only through substituting the architecture. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Baseline</td><td>AutoAugment</td><td>PBA</td><td>Our Method</td></tr><tr><td>ResNet-50</td><td>23.69 / 6.92</td><td>22.37 /6.18</td><td>1</td><td>20.60±0.15 /5.53±0.05</td></tr><tr><td>ResNet-50-D</td><td>22.84 / 6.48</td><td>1</td><td></td><td>20.00±0.12/5.25±0.03</td></tr><tr><td>ResNet-200</td><td>21.52 / 5.85</td><td>20.00 /4.90</td><td>1</td><td>18.68±0.18 /4.70±0.05</td></tr></table>",
+        "bbox": [
+            220,
+            386,
+            772,
+            459
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            472,
+            341,
+            486
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To check the effect of each component in our proposed method, we report the test error of ResNet-50 on ImageNet the following augmentation methods in Table 4. ",
+        "bbox": [
+            174,
+            494,
+            823,
+            523
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "• Baseline: Training regularly with the standard data augmentation and step LR schedule.   \n• Fixed: Augmenting all the instances of each batch with the standard data augmentation fixed throughout the entire training process. Random: Augmenting all the instances of each batch with randomly and dynamically generated policies. Ours: Augmenting all the instances of each batch with adversarial policies sampled by the policy network along with the training process. ",
+        "bbox": [
+            215,
+            535,
+            825,
+            647
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "From the table, we can find that Fixed can achieve $0 . 9 9 \\%$ error reduction compared to Baseline. This shows that a large-batch training with multiple augmented instances of each mini-batch can indeed improve the generalization of the model, which is consistent with the conclusion presented in Hoffer et al. (2019). In addition, the test error of Random is $1 . 0 2 \\%$ better than Fixed. This indicates that augmenting batch with randomly generated policies can reduce overfitting in a certain extent. Furthermore, our method achieves the best test error of $2 0 . 6 0 \\%$ through augmenting samples with adversarial policies. From the result, we can conclude that these policies generated by the policy network are more adaptive to the training process, and make the target network have to learn more robust features. ",
+        "bbox": [
+            173,
+            657,
+            825,
+            782
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.5 COMPUTING COST AND TIME OVERHEAD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            796,
+            504,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Computing Cost: The computation in target network training is reused for policy evaluation. This makes the computing cost in policy search become negligible. Although there exists an increase of computing cost in target network training, the total computing cost in training one target network with augmentation policies is quite small compared to prior work. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Time Overhead: Since we just train one target network with a large batch distributedly and simultaneously, the time overhead of the large-batch training is equal to the regular training. Meanwhile, the joint optimization of target network training and augmentation policy search dispenses with the process of offline policy search and the retraining of a target network, which leads to a extreme time overhead reduction. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0d33c9b0d3bb4d596dbaf5db23898beb2fc80c5c532a9c04e77237c677eaa18c.jpg",
+        "table_caption": [
+            "Table 4: Top-1 test error $( \\% )$ of ResNet-50 with different augmentation methods on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Aug. Policy</td><td>Enlarge Batch</td><td>LR Schedule</td><td>Test Error</td></tr><tr><td>Baseline</td><td>standard</td><td>M=1</td><td>step</td><td>23.69</td></tr><tr><td>Fixed</td><td>standard</td><td>M=8</td><td>cosine</td><td>22.70</td></tr><tr><td>Random</td><td>random</td><td>M=8</td><td>cosine</td><td>21.68</td></tr><tr><td>Ours</td><td>adversarial</td><td>M=8</td><td>cosine</td><td>20.60</td></tr></table>",
+        "bbox": [
+            256,
+            116,
+            736,
+            203
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            213,
+            825,
+            241
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In Table 5, we take the training of ResNet-50 on ImageNet as an example to compare the computing cost and time overhead of our method and AutoAugment. From the table, we can find that our method is $1 2 \\times$ less computing cost and $1 1 \\times$ shorter time overhead than AutoAugment. ",
+        "bbox": [
+            174,
+            248,
+            825,
+            290
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/f3bf8b2d6f177971a2bdad2dbb26e8734c9a3d3754c0e1aeba92d92343c857b2.jpg",
+        "table_caption": [
+            "Table 5: The comparison of computing cost (GPU hours) and time overhead (days) in training ResNet-50 on ImageNet between AutoAugment and our method. The computing cost and time overhead are estimated on 64 NVIDIA Tesla V100s. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td colspan=\"3\">Computing Cost</td><td colspan=\"3\">Time Overhead</td></tr><tr><td>Searching</td><td>Training</td><td>Total</td><td>Searching</td><td>Training</td><td>Total</td></tr><tr><td>AutoAugment</td><td>15000</td><td>160</td><td>15160</td><td>10</td><td>1</td><td>11</td></tr><tr><td>Our Method</td><td>~0</td><td>1280</td><td>1280</td><td>~0</td><td>1</td><td>1</td></tr></table>",
+        "bbox": [
+            222,
+            345,
+            772,
+            424
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "4.6 TRANSFERABILITY ACROSS DATASETS AND ARCHITECTURES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            640,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To further show the higher efficiency of our method, the transferability of the learned augmentation policies is evaluated in this section. We first take a snapshot of the adversarial training process of ResNet-50 on ImageNet, and then directly use the learned dynamic augmentation policies to regularly train the following models: Wide-ResNet-28-10 on CIFAR-10/100, ResNet-50-D on ImageNet and ResNet200 on ImageNet. Table 6 presents the experimental results of the transferability. From the table, we can find that a competitive performance can be still achieved through direct policy transfer. This indicates that the learned augmentation policies transfer well across datasets and architectures. However, compared to the proposed method, the policy transfer results in an obvious performance degradation, especially the transfer across datasets. ",
+        "bbox": [
+            173,
+            459,
+            825,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/e885dd982a0940ae52993dc12f9f60d83acd25879acc9f8565db376eeebf1417.jpg",
+        "table_caption": [
+            "Table 6: Top-1 test error $( \\% )$ of the transfer of the augmentation policies learned with ResNet-50 on ImageNet. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Dataset</td><td>AutoAugment</td><td>Our Method</td><td>Policy Transfer</td></tr><tr><td>Wide-ResNet-28-10</td><td>CIFAR-10</td><td>2.68</td><td>1.90</td><td>2.45±0.13</td></tr><tr><td>Wide-ResNet-28-10</td><td>CIFAR-100</td><td>17.09</td><td>15.49</td><td>16.48±0.15</td></tr><tr><td>ResNet-50-D</td><td>ImageNet</td><td>1</td><td>20.00</td><td>20.20±0.05</td></tr><tr><td>ResNet-200</td><td>ImageNet</td><td>20.00</td><td>18.68</td><td>19.05±0.10</td></tr></table>",
+        "bbox": [
+            204,
+            626,
+            789,
+            713
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            320,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we introduce the idea of adversarial learning into automatic data augmentation. The policy network tries to combat the overfitting of the target network through generating adversarial policies with the training process. To oppose this, robust features are learned in the target network, which leads to a significant performance improvement. Meanwhile, the augmentation policy search is performed along with the training of a target network, and the computation in network training is reused for policy evaluation, which can extremely reduce the search cost and make our method more computing-efficient. ",
+        "bbox": [
+            173,
+            753,
+            825,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            872,
+            285,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antreas Antoniou, Amos J. Storkey, and Harrison Edwards. Data augmentation generative adversarial networks. ICLR, 2017. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ekin D. Cubuk, Barret Zoph, Dandelion Mane, Vijay Vasudevan, and Quoc V. Le. Autoaugment: ´ Learning augmentation policies from data. CVPR, 2019. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jia Deng, Wei Dong, Richard Socher, Li-Jia Li, Kai Li, and Li Fei-Fei. Imagenet: A large-scale hierarchical image database. CVPR, 2009. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Terrance Devries and Graham W. Taylor. Improved regularization of convolutional neural networks with cutout. CoRR, abs/1708.04552, 2017. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Maayan Frid-Adar, Eyal Klang, Michal Amitai, Jacob Goldberger, and Hayit Greenspan. Synthetic data augmentation using GAN for improved liver lesion classification. IEEE International Symposium on Biomedical Imaging (ISBI), 2018. ",
+        "bbox": [
+            174,
+            215,
+            823,
+            260
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xavier Gastaldi. Shake-shake regularization. CoRR, abs/1705.07485, 2017. ",
+        "bbox": [
+            174,
+            267,
+            671,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ian J. Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair, Aaron Courville, and Yoshua Bengio. Generative adversarial networks. NIPS, 2014. ",
+        "bbox": [
+            173,
+            291,
+            823,
+            320
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minghao Guo, Zhao Zhong, Wei Wu, Dahua Lin, and Junjie Yan. IRLAS: inverse reinforcement learning for architecture search. CoRR, abs/1812.05285, 2018. ",
+        "bbox": [
+            174,
+            329,
+            823,
+            358
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Swaminathan Gurumurthy, Ravi Kiran Sarvadevabhatla, and Venkatesh Babu Radhakrishnan. Deligan : Generative adversarial networks for diverse and limited data. CVPR, 2017. ",
+        "bbox": [
+            173,
+            367,
+            821,
+            396
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dongyoon Han, Jiwhan Kim, and Junmo Kim. Deep pyramidal residual networks. CVPR, 2017. ",
+        "bbox": [
+            176,
+            405,
+            805,
+            421
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. CVPR, 2016. ",
+        "bbox": [
+            173,
+            429,
+            821,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tong He, Zhi Zhang, Hang Zhang, Zhongyue Zhang, Junyuan Xie, and Mu Li. Bag of tricks for image classification with convolutional neural networks. CoRR, abs/1812.01187, 2018. ",
+        "bbox": [
+            174,
+            467,
+            823,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Daniel Ho, Eric Liang, Ion Stoica, Pieter Abbeel, and Xi Chen. Population based augmentation: Efficient learning of augmentation policy schedules. ICML, 2019. ",
+        "bbox": [
+            171,
+            503,
+            821,
+            534
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural Computation, 1997. ",
+        "bbox": [
+            174,
+            541,
+            812,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elad Hoffer, Tal Ben-Nun, Itay Hubara, Niv Giladi, Torsten Hoefler, and Daniel Soudry. Augment your batch: better training with larger batches. CoRR, abs/1901.09335, 2019. ",
+        "bbox": [
+            171,
+            565,
+            823,
+            594
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Hiroshi Inoue. Data augmentation by pairing samples for images classification. CoRR, abs/1801.02929, 2018. ",
+        "bbox": [
+            173,
+            603,
+            823,
+            632
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Max Jaderberg, Valentin Dalibard, Simon Osindero, Wojciech M. Czarnecki, Jeff Donahue, Ali Razavi, Oriol Vinyals, Tim Green, Iain Dunning, Karen Simonyan, Chrisantha Fernando, and Koray Kavukcuoglu. Population based training of neural networks. CoRR, abs/1711.09846, 2017. ",
+        "bbox": [
+            173,
+            640,
+            825,
+            696
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015. ",
+        "bbox": [
+            169,
+            707,
+            795,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey E. Hinton. Learning multiple layers of features from tiny images. Technical report, University of Toronto, 2009. ",
+        "bbox": [
+            168,
+            731,
+            821,
+            760
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E. Hinton. Imagenet classification with deep convolutional neural networks. NIPS, 2012. ",
+        "bbox": [
+            171,
+            767,
+            823,
+            796
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Joseph Lemley, Shabab Bazrafkan, and Peter Corcoran. Smart augmentation - learning an optimal data augmentation strategy. CoRR, abs/1703.08383, 2017. ",
+        "bbox": [
+            171,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chen Lin, Minghao Guo, Chuming Li, Wei Wu, Dahua Lin, Wanli Ouyang, and Junjie Yan. Online hyper-parameter learning for auto-augmentation strategy. CoRR, abs/1905.07373, 2019. ",
+        "bbox": [
+            171,
+            843,
+            825,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xi Peng, Zhiqiang Tang, Fei Yang, Rogerio Schmidt Feris, and Dimitris N. Metaxas. Jointly op- ´ timize data augmentation and network training: Adversarial data augmentation in human pose estimation. CVPR, 2018. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luis Perez and Jason Wang. The effectiveness of data augmentation in image classification using deep learning. CoRR, abs/1712.04621, 2017. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Julian Salazar, Davis Liang, Zhiheng Huang, and Zachary C. Lipton. Invariant representation learning for robust deep networks. NeurIPS Workshop, 2018. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott E. Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. CVPR, 2015. ",
+        "bbox": [
+            178,
+            178,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Toan Tran, Trung Pham, Gustavo Carneiro, Lyle J. Palmer, and Ian D. Reid. A bayesian data augmentation approach for learning deep models. NIPS, 2017. ",
+        "bbox": [
+            171,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Li Wan, Matthew Zeiler, Sixin Zhang, Yann LeCun, and Rob Fergus. Regularization of neural networks using dropconnect. ICML, 2013. ",
+        "bbox": [
+            171,
+            267,
+            825,
+            297
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Xiaolong Wang, Abhinav Shrivastava, and Abhinav Gupta. A-fast-rcnn: Hard positive generation via adversary for object detection. CVPR, 2017. ",
+        "bbox": [
+            173,
+            306,
+            823,
+            334
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning, 1992. ",
+        "bbox": [
+            173,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yoshihiro Yamada, Masakazu Iwamura, and Koichi Kise. Shakedrop regularization. CoRR, abs/1802.02375, 2018. ",
+        "bbox": [
+            174,
+            381,
+            823,
+            410
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. British Machine Vision Conference, 2016. ",
+        "bbox": [
+            174,
+            419,
+            821,
+            448
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhao Zhong, Junjie Yan, and Cheng-Lin Liu. Practical network blocks design with Q-learning. CVPR, 2018a. ",
+        "bbox": [
+            173,
+            457,
+            820,
+            486
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhao Zhong, Zichen Yang, Boyang Deng, Junjie Yan, Wei Wu, Jing Shao, and Cheng-Lin Liu. BlockQNN: Efficient block-wise neural network architecture generation. CoRR, abs/1808.05584, 2018b. ",
+        "bbox": [
+            173,
+            494,
+            825,
+            536
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V. Le. Neural architecture search with reinforcement learning. ICLR, 2016. ",
+        "bbox": [
+            174,
+            546,
+            818,
+            560
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph, Vijay Vasudevan, Jonathon Shlens, and Quoc V. Le. Learning transferable architectures for scalable image recognition. CVPR, 2017. ",
+        "bbox": [
+            174,
+            570,
+            821,
+            598
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "bbox": [
+            176,
+            616,
+            299,
+            632
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            642,
+            361,
+            657
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We detail the model hyperparameters on CIFAR-10/CIFAR-100 and ImageNet in Table 7. ",
+        "bbox": [
+            171,
+            669,
+            761,
+            684
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/805358f66a6525e1f2d65ec0f4b18937182bf4e5a10355c998155b8c28719ccb.jpg",
+        "table_caption": [
+            "Table 7: Model hyperparameters on CIFAR-10/CIFAR-100 and ImageNet. LR represents learning rate, and WD represents weight decay. We do not specifically tune these hyperparameters, and all of these are consistent with previous works, expect for the number of epochs. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>Model</td><td>Batch Size (N · M)</td><td>LR</td><td>WD</td><td>Epoch</td></tr><tr><td>CIFAR-10</td><td>Wide-ResNet-28-10</td><td>128·8</td><td>0.1</td><td>5e-4</td><td>200</td></tr><tr><td>CIFAR-10</td><td>Shake-Shake (26 2x32d)</td><td>128·8</td><td>0.2</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-10</td><td>Shake-Shake ( (262x96d)</td><td>128·8</td><td>0.2</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-10</td><td>Shake-Shake (26 2x112d)</td><td>128·8</td><td>0.2</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-10</td><td>PyramidNet+ShakeDrop</td><td>128·8</td><td>0.1</td><td>1e-4</td><td>600</td></tr><tr><td>CIFAR-100</td><td>Wide-ResNet-28-10</td><td>128·8</td><td>0.1</td><td>5e-4</td><td>200</td></tr><tr><td>CIFAR-100</td><td>Shake-Shake (26 2x96d)</td><td>128·8</td><td>0.1</td><td>5e-4</td><td>1200</td></tr><tr><td>CIFAR-100</td><td>PyramidNet+ShakeDrop</td><td>128·8</td><td>0.5</td><td>1e-4</td><td>1200</td></tr><tr><td>ImageNet</td><td>ResNet-50</td><td>2048·8</td><td>0.8</td><td>1e-4</td><td>120</td></tr><tr><td>ImageNet</td><td>ResNet-50-D</td><td>2048·8</td><td>0.8</td><td>1e-4</td><td>120</td></tr><tr><td>ImageNet</td><td>ResNet-200</td><td>2048·8</td><td>0.8</td><td>1e-4</td><td>120</td></tr></table>",
+        "bbox": [
+            233,
+            428,
+            764,
+            637
+        ],
+        "page_idx": 12
+    }
+]

parse/train/KUDUoRsEphu/KUDUoRsEphu.md

@@ -0,0 +1,362 @@
+# LEARNING INCOMPRESSIBLE FLUID DYNAMICS FROM SCRATCH - TOWARDS FAST, DIFFERENTIABLE FLUID MODELS THAT GENERALIZE
+
+Nils Wandel   
+Department of Computer Science University of Bonn   
+wandeln@cs.uni-bonn.de   
+Michael Weinmann   
+Department of Computer Science   
+University of Bonn   
+mw@cs.uni-bonn.de   
+Reinhard Klein   
+Department of Computer Science   
+University of Bonn   
+rk@cs.uni-bonn.de
+
+# ABSTRACT
+
+Fast and stable fluid simulations are an essential prerequisite for applications ranging from computer-generated imagery to computer-aided design in research and development. However, solving the partial differential equations of incompressible fluids is a challenging task and traditional numerical approximation schemes come at high computational costs. Recent deep learning based approaches promise vast speed-ups but do not generalize to new fluid domains, require fluid simulation data for training, or rely on complex pipelines that outsource major parts of the fluid simulation to traditional methods.
+
+In this work, we propose a novel physics-constrained training approach that generalizes to new fluid domains, requires no fluid simulation data, and allows convolutional neural networks to map a fluid state from time-point $t$ to a subsequent state at time $t + d t$ in a single forward pass. This simplifies the pipeline to train and evaluate neural fluid models. After training, the framework yields models that are capable of fast fluid simulations and can handle various fluid phenomena including the Magnus effect and Kármán vortex streets. We present an interactive real-time demo to show the speed and generalization capabilities of our trained models. Moreover, the trained neural networks are efficient differentiable fluid solvers as they offer a differentiable update step to advance the fluid simulation in time. We exploit this fact in a proof-of-concept optimal control experiment. Our models significantly outperform a recent differentiable fluid solver in terms of computational speed and accuracy.
+
+# 1 INTRODUCTION
+
+Simulating the behavior of fluids by solving the incompressible Navier-Stokes equations is of great importance for a wide range of applications and accurate as well as fast fluid simulations are a long-standing research goal. On top of simulating the behavior of fluids, several applications such as sensitivity analysis of fluids or gradient-based control algorithms rely on differentiable fluid simulators that allow to propagate gradients throughout the simulation (Holl et al. (2020)).
+
+Recent advances in deep learning aim for fast and accurate fluid simulations but rely on vast datasets and / or do not generalize to new fluid domains. Kim et al. (2019) present a framework to learn parameterized fluid simulations and allow to interpolate efficiently in between such simulations. However, their work does not generalize to new domain geometries that lay outside the training data. Kim & Lee (2020) train a RNN-GAN that produces turbulent flow fields within a pipe domain, but do not show generalization results beyond pipe domains. Xie et al. (2018) introduce a tempoGAN to perform temporally consistent superresolution of smoke simulations. This allows to produce plausible high-resolution smoke-density fields for arbitrary low-resolution inputs, but our fluid model should output a complete fluid state description consisting of a velocity and a pressure field. Tompson et al. (2017) present how a Helmholtz projection step can be learned to accelerate Eulerian fluid simulations. This method generalizes to new domain geometries, but a particle tracer is needed to deal with the advection term of the Navier-Stokes equations. Furthermore, as Eulerian fluids do not model viscosity, effects like e.g. the Magnus effect or Kármán vortex streets cannot be simulated. Geneva & Zabaras (2020) propose a physics-informed framework to learn the entire update step for the Burgers equations in 1D and 2D, but no generalization results for new domain geometries are demonstrated. All of the aforementioned methods rely on the availability of vast amounts of data from fluid-solvers such as FEniCS, OpenFOAM or Mantaflow. Most of these methods do not generalize well or outsource a major part of the fluid simulation to traditional methods such as low-resolution fluid solvers or a particle tracer.
+
+In this work, we propose a novel unsupervised training framework to learn incompressible fluid dynamics from scratch. It does not require any simulated fluid-data (neither as ground truth data, nor to train an adversarial network, nor to initialize frames for a physics-constrained loss) and generalizes to fluid domains unseen during training. It allows CNNs to learn the entire update-step of mapping a fluid domain from time-point $t$ to $t + d t$ without having to rely on low resolution fluid-solvers or a particle-tracer. In fact, we will demonstrate that a physicsconstrained loss function combined with a simple strategy to recycle fluid-data generated by the neural network at training time suffices to teach CNNs fluid dynamics on increasingly realistic statistics of fluid states. This drastically simplifies the training pipeline. Fluid simulations get efficiently unrolled in time by recurrently applying the trained model on a fluid state. Furthermore, the fluid models include viscous friction and handle effects such as the Magnus effect and Kármán vortex streets. On top of that, we show by a gradient-based optimal control example how backpropagation through time can be used to differentiate the fluid simulation. Code and pretrained models are publicly available at https://github.com/aschethor/ Unsupervised_Deep_Learning_of_Incompressible_Fluid_Dynamics/.
+
+# 2 RELATED WORK
+
+In literature, several different approaches can be found that aim to approximate the dynamics of PDEs in general and fluids in particular with efficient, learning-based surrogate models.
+
+Lagrangian methods such as smoothed particle hydrodynamcs (SPH) Gingold & Monaghan (1977) handle fluids from the perspective of many individual particles that move with the velocity field. Following this approach, learning-based methods using regression forests by Ladický et al. (2015), graph neural networks by Mrowca et al. (2018); Li et al. (2019) and continuous convolutions by Ummenhofer et al. (2020) have been developed. In addition, Smooth Particle Networks (SP-Nets) by Schenck & Fox (2018) allow for differentiable fluid simulations within the Lagrangian frame of reference. These Lagrangian methods are particularly suitable when a fluid domain exhibits large, dynamic surfaces (e.g. waves or droplets). However, to simulate the dynamics within a fluid domain accurately, Eulerian methods, that treat the Navier-Stokes equations in a fixed frame of reference, are usually better suited.
+
+Continuous Eulerian methods allow for mesh-free solutions by mapping domain coordinates (e.g. $x , y , t )$ directly onto field values (e.g. velocity $\vec { v } \ : /$ pressure $p$ ) (Sirignano & Spiliopoulos (2018); Grohs et al. (2018); Khoo et al. (2019)). Recent applications focused on flow through porous media (Zhu & Zabaras (2018); Zhu et al. (2019); Tripathy & Bilionis (2018)), fluid modeling (Yang et al. (2016); Raissi et al. (2018)), turbulence modeling (Geneva & Zabaras (2019); Ling et al. (2016)) and modeling of molecular dynamics (Schöberl et al. (2019)). Training is usually based on physics-constrained loss functions that penalize residuals of the underlying PDEs. Similar to our approach, Raissi et al. (2019) uses vector potentials to obtain continuous divergence-free velocity fields to approximate the incompressible Navier-Stokes equations. Continuous methods return smooth, accurate results and can overcome the curse of dimensionality of discrete techniques in high-dimensional PDEs (Grohs et al. (2018)). However, these networks are trained on a specific domain and cannot generalize to new environments or be used in interactive scenarios.
+
+Discrete Eulerian methods, on the other hand, aim to solve the underlying PDEs on a grid and early work dates back to Harlow & Welch (1965) and Stam (1999). Accelerating such traditional works with deep learning techniques is a major field of research and all of the methods mentioned in the introduction fall into this category. Further methods include the approach by Thuerey et al. (2019) to learn solutions of the Reynolds-averaged Navier-Stokes equations for airfoil flows, but requires large amounts of training data and does not generalize beyond airfoil flows. In the work by Um et al. (2020), a correction step is learned that brings solutions of a low-resolution differentiable fluid solver closer to solutions of a high-resolution fluid simulation. However, generalization results for new domain geometries were not presented. The works of Mohan et al. (2020) and Kim et al. (2019) show that vector potentials are suitable to enforce the incompressibility constraint in fluids but do not generalize to new fluid domains beyond their training data.
+
+# 3 METHOD
+
+In this section, we briefly review the incompressible Navier-Stokes equations, which are to be solved by the neural network. Then, we explain how the Helmholtz decomposition can be exploited to ensure incompressibility within the fluid domain. Furthermore, we provide details of our discrete spatio-temporal fluid representation and introduce the fluid model. Afterwards, we formulate a physics-constrained loss function based on residuals of the Navier-Stokes equations and introduce a pressure regularization term for very high Reynolds numbers. Finally, we explain the unsupervised training strategy.
+
+# 3.1 INCOMPRESSIBLE NAVIER-STOKES EQUATIONS
+
+Most fluids can be modeled with the incompressible Navier-Stokes equations - a set of non-linear equations that describe the interplay of a velocity field $\vec { v }$ and a pressure field $p$ within a fluid domain $\Omega$ :
+
+$$
+\begin{array} { r l r } { \boldsymbol { \nabla } \cdot \boldsymbol { \vec { v } } = 0 } & { \mathrm { i n c o m p r e s s i b i l i t y ~ o n ~ } \Omega } \\ { \rho \dot { \vec { v } } = \rho \left( \frac { \partial \vec { v } } { \partial t } + \left( \vec { v } \cdot \boldsymbol { \nabla } \right) \vec { v } \right) = - \boldsymbol { \nabla } p + \mu \Delta \vec { v } + \vec { f } } & { \mathrm { c o n s e r v a t i o n ~ o f ~ m o m e n t u m ~ o n ~ } \Omega } \end{array}
+$$
+
+Here, $\rho$ describes the fluid density and $\mu$ the viscosity. Equation 1 states that the fluid is incompressible and thus $\vec { v }$ is divergence-free. Equation 2 states that the change in momentum of fluid particles must correspond to the sum of forces that arise from the pressure gradient, viscous friction and external forces. Here, external forces on the fluid (such as e.g. gravity) can be neglected, so we set ${ \vec { f } } = 0$ .
+
+These incompressible Navier-Stokes equations shall be solved by a CNN given initial conditions $\vec { v } ^ { 0 }$ and $p ^ { 0 }$ at the beginning of the simulation and Dirichlet boundary conditions which constrain the velocity field at the domain boundary $\partial \Omega$ :
+
+$$
+\vec { v } = \vec { v } _ { d } \qquad \mathrm { D i r i c h l e t ~ b o u n d a r y ~ c o n d i t i o n ~ o n ~ } \partial \Omega
+$$
+
+# 3.2 HELMHOLTZ DECOMPOSITION
+
+A common method to ensure incompressibility of a fluid (see Equation 1) is to project the flow field onto the divergence-free part of its Helmholtz decomposition. The Helmholtz theorem states that every vector field $\vec { v }$ can be decomposed into a curl-free part $( \nabla q )$ and a divergence-free part $( \nabla \times \vec { a } )$ :
+
+$$
+\vec { v } = \nabla q + \nabla \times \vec { a }
+$$
+
+Note, that $\nabla \times ( \nabla q ) = \vec { 0 }$ and $\nabla \cdot ( \nabla \times { \vec { a } } ) = 0$ . The Helmholtz projection consists of solving the Poisson problem $\nabla \cdot \vec { v } = \Delta q$ for $q$ , followed by substracting $\nabla q$ from the original flow field. However, solving the Poisson equation on arbitrary domains comes at high computational costs for classical methods and one has to rely e.g. on conjugate gradient methods to approximate its solution.
+
+Here, we propose a different approach and directly try to learn a vector potential $\vec { a }$ with $\vec { v } = \nabla \times \vec { a }$ . This ensures that the network outputs a divergence-free velocity field within the domain $\Omega$ and automatically solves Equation 1. In this work, we consider 2D fluid simulations, so only the $\mathbf { Z }$ - component of $\vec { a }$ , $a _ { z }$ , is of interest since $v _ { z }$ and all derivatives with respect to the $z$ -axis are zero:
+
+$$
+\nabla \times { \vec { a } } = \left( { \partial _ { z } a _ { x } - \partial _ { z } a _ { y } } \right) = \left( { \partial _ { y } a _ { z } } \right) = \left( { \begin{array} { c } { v _ { x } } \\ { v _ { y } } \\ { 0 } \end{array} } \right) = { \vec { v } }
+$$
+
+# 3.3 DISCRETE SPATIO-TEMPORAL FLUID REPRESENTATION
+
+Marker-And-Cell (MAC) grid To solve the Navier-Stokes equations, we represent the relation between $a _ { z } , v _ { x } , v _ { y } , p$ on a 2D staggered marker-and-cell (MAC) grid (see Figure 1a). Therefore, we discretise time and space as follows:
+
+$$
+\vec { a } ( x , y , t ) = \left( \begin{array} { c } { 0 } \\ { 0 } \\  \left( a _ { z } \right) _ { i , j } ^ { t } \rule { 0 ex } { 5 ex } \right) ; \vec { v } ( x , y , t ) = \binom { \left( v _ { x } \right) _ { i , j } ^ { t } } { \left( v _ { y } \right) _ { i , j } ^ { t } } ; p ( x , y , t ) = p _ { i , j } ^ { t } \end{array}
+$$
+
+Obtaining gradient, divergence, Laplace and curl operations on this grid with finite differences is straight forward and can be efficiently implemented with convolutions (see appendix A).
+
+![](images/9b2df2899d456e4e435eca52239a4b16982712cebefb7099762ffba6f6c0e6f2.jpg)  
+Figure 1: MAC grid and diagram of the fluid model.
+
+Explicit, Implicit, Implicit-Explicit (IMEX) time integration methods The discretization of the time domain is needed to deal with the time-derivative of the velocity fiel d ∂\~v∂t in Equation 2, which becomes:
+
+$$
+\rho \left( \frac { \vec { v } ^ { t + d t } - \vec { v } ^ { t } } { d t } + \left( \vec { v } ^ { t ^ { \prime } } \cdot \nabla \right) \vec { v } ^ { t ^ { \prime } } \right) = - \nabla p ^ { t + d t } + \mu \Delta \vec { v } ^ { t ^ { \prime } } + \vec { f }
+$$
+
+The goal is to take as large as possible timesteps $d t$ while maintaining stable and accurate solutions. Stability and accuracy largely depend on the definition of $v ^ { t ^ { \prime } }$ . In literature, choosing $\boldsymbol { v } ^ { t ^ { \prime } } = \boldsymbol { v } ^ { t }$ is often referred to as explicit integration methods and frequently leads to unstable behavior. Choosing $v ^ { t ^ { \prime } } = v ^ { t + d t }$ is usually associated with implicit integration methods and gives stable solutions at the cost of numerical dissipation. Implicit-Explicit (IMEX) methods, which set $v ^ { t ^ { \prime } } = ( v ^ { t } + v ^ { t + d t } ) / 2$ are a compromise between both methods and considered to be more accurate but less stable than implicit methods.
+
+# 3.4 FLUID MODEL
+
+We represent the fluid dynamics by a recurrent model that maps the fluid state $p ^ { t } , \vec { a } ^ { t }$ for timestep $t$ and the domain description $\Omega ^ { t + d t } , \vec { v } _ { d } ^ { t + d t }$ to the fluid state $p ^ { t + d t } , \vec { a } ^ { t + d t }$ of the next timestep. Here, $p ^ { t }$ describes the pressure field and $\vec { a } ^ { t }$ describes the vector potential of . For $t = 0$ , we consider initial states $p ^ { 0 } = 0$ and $\vec { a } ^ { 0 } = \vec { 0 }$ , however, other initial conditions could be considered as well. $\Omega ^ { t + d t }$ is a binary mask that contains the domain geometry and is 1 for the fluid domain and 0 everywhere else. For the boundary of the domain, we simply take the inverse of $\Omega \colon \partial \Omega = 1 - \Omega$ . $\vec { v } _ { d } ^ { t + \dot { d } t }$ represents the Dirichlet boundary conditions and contains a velocity field that must be matched by ${ \vec { v } } ^ { t + d t }$ at the domain boundaries. Figure 1b shows a diagram of the fluid model. First, $\left( p ^ { t } , \vec { a } ^ { t } , \Omega ^ { t + d t } , \vec { v } _ { d } ^ { t + d t } \right)$ are taken to derive a slightly more meaningful feature representation that comprises $\left( p ^ { t } , a ^ { t } , \nabla \times a ^ { t } , \Omega ^ { t + d t } , \partial \Omega ^ { t + d t } , \Omega ^ { t + d t } \cdot \nabla \times a ^ { t } , \Omega ^ { t + d t } \cdot p ^ { t } , \partial \Omega ^ { t + d t } \cdot \vec { v } _ { d } ^ { t + d t } \right)$ . These features can be very efficiently computed with convolutions and are then fed into a U-Net (Ronneberger et al. (2015)) with a reduced number of channels (the exact network configuration can be found in appendix B). The mean of the U-Net output is set to 0 in order to keep $p$ and $\vec { a }$ well defined and prevent drifting offset values. Finally, the output is added to $p ^ { t }$ and $\vec { a } ^ { t }$ to obtain the updated fluid state $p ^ { t + d t }$ and $\vec { a } ^ { t + d t }$ .
+
+# 3.5 PHYSICS-CONSTRAINED LOSS FUNCTION
+
+Using the residuals of the Navier-Stokes equations (Equations 1 and 2), we can formulate the following loss terms on $\Omega$ and $\partial \Omega$ :
+
+$$
+\begin{array} { l l } { { L _ { d } = \displaystyle { \left\| \nabla \cdot \vec { v } \right\| ^ { 2 } } } } & { { \qquad \mathrm { ~ d i v e r g e n c e ~ l o s s ~ o n ~ } \Omega } } \\ { { L _ { p } = \displaystyle { \left\| \rho \left( \frac { \partial \vec { v } } { \partial t } + \left( \vec { v } \cdot \nabla \right) \vec { v } \right) + \nabla p - \mu \Delta \vec { v } - \vec { f } \right\| ^ { 2 } } } } & { { \qquad \mathrm { ~ m o m e n t u m ~ l o s s ~ o n ~ } \Omega } } \\ { { L _ { b } = \displaystyle { \left\| \vec { v } - \vec { v } _ { d } \right\| ^ { 2 } } } } & { { \qquad \mathrm { ~ b o u n d a r y ~ l o s s ~ o n ~ } \partial \Omega } } \end{array}
+$$
+
+Combining the described loss terms, we obtain the following loss function:
+
+$$
+L = \alpha L _ { d } + \beta L _ { p } + \gamma L _ { b }
+$$
+
+where $\alpha , \beta , \gamma$ are hyperparameters that weight the contributions of the different loss terms. Note that if we use a vector potential ${ \vec { v } } = \nabla \times { \vec { a } }$ , $L _ { d } = 0$ is automatically fulfilled and we can set $\alpha = 0$ . This loss function can be computed very efficiently with convolutions in $O ( N )$ (where $N =$ number of grid cells), whereas solving the Navier-Stokes equations explicitly would be computationally a lot more expensive. For detailed descriptions regarding the fully discretized loss-function, we refer to appendix A.
+
+# 3.6 PRESSURE REGULARIZATION
+
+For very high Reynolds numbers (see Equation 13) and inviscid flows, training becomes unstable as viscous friction cannot dissipate enough energy out of the system. This leads to unrealistic gradients in $\vec { v }$ and $p$ . For such cases, we introduce an additional regularization term for the loss function (11) that can be traded off with $L _ { p }$ to stabilize training:
+
+$$
+L _ { r } = \| \nabla p \| ^ { 2 }
+$$
+
+The intuition behind this regularization term is, that we want to penalize unrealistically high energies in the pressure field.
+
+# 3.7 TRAINING STRATEGY
+
+Training starts with initializing a pool $\{ \Omega _ { k } ^ { 0 } , ( v _ { d } ) _ { k } ^ { 0 } , ( a _ { z } ) _ { k } ^ { 0 } , p _ { k } ^ { 0 } \}$ of randomized domains $\Omega _ { k } ^ { 0 }$ and boundary conditions $( v _ { d } ) _ { k } ^ { 0 }$ as well as initial conditions for the vector potential and pressure fields that we both set to zero $( \check { ( a _ { z } ) } _ { k } ^ { 0 } = 0$ and $p _ { k } ^ { 0 } = 0$ ). The resolution of our training domains is $1 0 0 \mathrm { x } 3 0 0$ grid cells and example-domains of the training pool are shown in appendix C. Note that our training pool does not rely on any previously simulated fluid-data.
+
+At each training step, a random mini-batch $\{ \Omega _ { k } ^ { t } , ( v _ { d } ) _ { k } ^ { t } , ( a _ { z } ) _ { k } ^ { t } , p _ { k } ^ { t } \} _ { \{ k \in \operatorname * { m i n i b a t c h } \} }$ is drawn from the pool and fed into the neural network which is designed to predict the velocity $( \vec { v } _ { k } ^ { t + d t } = \nabla \times \vec { a } _ { k } ^ { t + d t } )$ and pressure $( p _ { k } ^ { t + d t } )$ fields of the next time step. Based on a physics-constrained loss-function (Equation 11), we update the weights of the network using the Adam optimizer (Kingma & Ba (2015)). At the end of each training step, the pool is updated by replacing the old vector potential and pressure fields $( a _ { z } ) _ { k } ^ { t } , p _ { k } ^ { t }$ by the newly predicted ones $( a _ { z } ) _ { k } ^ { t + \dot { d t } } , p _ { k } ^ { \dot { t } + d t }$ t, pt+dtk . This recycling strategy fills the training pool with more and more realistic fluid states as the model becomes better at simulating fluid dynamics.
+
+From time to time, old environments of the training pool are replaced by new randomized environments and the vector potential as well as the pressure fields are reset to 0. This increases the variance of the training pool and helps the neural network to learn "cold starts" from \~0-velocity and 0-pressure fields.
+
+Besides the fluid model described above, which we denote as $\vec { a }$ -Net in the following, we also trained an ablation model, $\vec { v }$ -Net, that directly learns to predict the velocity field without a vector potential. For the implementation of both models, we used the popular machine learning framework Pytorch and trained the models on a NVidia GeForce RTX 2080 Ti. Training converged after about 1 day. The hyperparameters in the loss-function for the $\vec { a }$ -Net were $\beta = 1$ and $\gamma = 2 0$ . The reason for choosing a higher weight for the loss term $L _ { b }$ than for $L _ { p }$ was the observation, that errors in $L _ { b }$ can lead to unrealistic flows leaking through boundaries. For the ablation study $\vec { v } \cdot \vec { }$ -Net), we used $\alpha = 1 0 0 , \beta = 1 , \gamma = 0 . 0 0 1$ . Here, we had to choose a very high weight for $L _ { d }$ to ensure incompressibility of the fluid, otherwise unrealistic source and sink effects start to appear. For $L _ { b }$ , on the other hand, we used a very low weight as the boundary conditions can be trivially learned by the $\vec { v }$ -Net. We used these parameter settings for all experiments.
+
+# 4 RESULTS
+
+To evaluate the potential of our method, we assess its ability to reproduce physical effects such as Kármán vortex streets and the Magnus effect. In addition, we demonstrate its generalization capability and real-time performance. Finally, we test the fluid models quantitatively.
+
+# 4.1 QUALITATIVE EVALUATION
+
+Qualitative analysis of wake dynamics Qualitative effects in fluid dynamics such as the wake dynamics behind an obstacle are closely related to the Reynolds number. It is a dimensionless quantity defined by:
+
+$$
+R e = \frac { \rho \left\| \vec { v } \right\| D } { \mu }
+$$
+
+Here, $\rho$ is the fluid density, $\lVert \vec { v } \rVert$ is the fluid speed, $D$ is the diameter of the obstacle, and $\mu$ is the viscosity. (We use the units of the grid).
+
+We retrained models for different values of $\mu$ and $\rho$ to compare the fluid behavior for a wide range of Reynolds numbers. Figure 2 shows, that the trained models are able to predict the wake dynamics behind an obstacle in good accordance with qualitative expectations from fluid dynamics. As a rule of thumb, for $R e \ll 1$ , the flow becomes time-reversible. This can be noticed in Figure 2a by the symmetry of the flow before and after the obstacle and the nearly constant pressure gradient within the pipe. Starting from $R e \approx 1 0$ , the flow is still laminar but a static wake is forming behind the obstacle (see Figure 2b). For Reynolds numbers $R e > \approx 9 0$ , Kármán vortex streets start to appear (see Figure 2c). A Kármán vortex street consists of clock and counterclockwise spinning vortices that are generated at the obstacle and then start moving in a regularly oscillating pattern with the flow. For very large Reynolds numbers or inviscid flows, the flow field becomes turbulent, which can be recognized by the irregular patterns behind the obstacle in Fig 2d.
+
+![](images/468c39a4bc3b15c1ad09df22f1ea2d017e585da0b07e13fdda3acc4af90342a2.jpg)  
+Figure 2: After training, our models are able to show correct wake flow dynamics for a wide range of different Reynolds numbers. $\dot { \boldsymbol { D } } = 3 0$ , $\| \vec { v } \| = 0 . 5 )$ . Streamlines indicate flow direction, linewidth indicates speed and colors represent the pressure field (blue: low pressure / yellow: high pressure).
+
+Magnus effect The Magnus effect appears when a flow interacts with a rotating body. It is widely known e.g. in sports such as soccer or tennis where spin is used to deflect the path of a ball. The reason for the deflection stems from a low pressure field where the surface of the object moves along flow direction and a high pressure field where the object surface moves against the flow. Figure 3a shows, that our models are able to reproduce the Magnus effect around a rotating cylinder.
+
+![](images/f016ae8a12c9f62a822e83f75f847c39d114a2759991e05eb174aa68cf62956a.jpg)  
+(a) Magnus effect on a clock-wise turning cylinder.(b) Generalization example: Note that the fluid model has never been confronted with wingprofiles during training.
+
+Figure 3: Our models feature the Magnus effect and generalize to new fluid domains. Further examples are presented in appendix D and the video.
+
+Analysis of generalization capability We tested the networks capability to generalize to objects not seen during training. Figure 3b shows the networks capability to meet boundary conditions of an airfoil and return a plausible pressure field that produces lift (see low pressure on top of wing). Note that in contrast to the approach by Thuerey et al. (2019), which learns simplified, time-averaged solutions of the Navier-Stokes equations, our method is able to simulate the full incompressible Navier-Stokes equations for an airfoil without relying on any ground truth data or having seen airfoilgeometries during training. In fact, the network was only trained on simple randomized domains as highlighted in appendix C and Figure 7. Possible reasons for the networks generalization capabilities are:
+
+• During training, the network gets confronted with an infinite number of different flowfields and randomized domain configurations because the training pool gets updated at every training step. This prevents the network from over-fitting.
+
+• The dynamics of a fluid-particle are mostly determined by its local neighborhood / surrounding particles. This means, the update step for a certain cell on the MAC grid is mostly determined by close / neighboring MAC-grid cells. Since more complicated shapes can be seen locally as a composition of basic shapes (e.g. the front of the wing can be locally regarded as a cylinder), it suffices to train on basic shapes that provide the network with enough examples to generalize to more complicated shapes.
+
+Further generalization examples are provided in appendix D.
+
+Real-time capability The fluid simulation can be easily parallelized and takes low computational costs as one time-integration step consists just of a single forward pass through a convolutional neural network. This enables for example interactive real-time simulations. We implemented a demo that allows to interact with a fluid by moving obstacles, rotating spheres and changing the flow speed within a pipe (see video in supplementary material and source code). Our method runs at 250 timesteps per second on a $1 0 0 \mathrm { x } 3 0 0$ grid. In the respective experiments, we used a NVidia GeForce RTX 2080 Ti consuming about $8 6 0 \mathrm { M B }$ of GPU memory.
+
+# 4.2 QUANTITATIVE EVALUATION
+
+We compare our method $\vec { a }$ -Net) quantitatively with PhiFlow by Holl et al. (2020). Phiflow is a recent, open source, differentiable fluid simulator based on a MAC grid data structure. Furthermore, we provide an ablation study ${ \vec { v } } .$ -Net) that does not make use of the Helmholtz decomposition but directly works on the velocity field $\vec { v }$ .
+
+Quantitative comparison of different fluid solvers is challenging, as their performance is highly dependent on factors like the geometry of the domain, fluid parameters such as viscosity or density, flow speed or the timestep of the integrator. As benchmarks for fluid simulations on MAC grids are not yet available, we built a simple toy domain on a $1 0 0 \mathrm { ~ x ~ } 1 0 0$ grid which simulates a flow around an obstacle within a pipe (more details are provided in appendix E).
+
+First, we compared the computational speed on a CPU and GPU by comparing the integration time-steps per second (see Table 1). The $\vec { v }$ -Net as well as the $\vec { a }$ -Net are significantly faster than PhiFlow (11x on CPU and $4 0 \mathrm { x }$ on GPU) as they do not rely on an iterative conjugate gradient solver but instead use a single forward pass through a convolutional neural network that can be easily parallelized on a GPU. To provide a fair comparison on $L _ { d }$ , we set the velocity field at the boundaries equal to $\vec { v _ { d } }$ . This enables us to compute $L _ { d }$ for the $\vec { a }$ -Net architecture on the domain boundaries which would otherwise have zero divergence everywhere. This way, $L _ { d }$ can be interpreted as a metric on how well the orthogonal components of the Dirichlet boundary conditions are met (i.e. no flow leaks through the boundaries). For $d t = 4$ , we outperformed Phiflow by several orders of magnitude. For both, $L _ { d }$ and $L _ { p }$ , the $\vec { a }$ -Net architecture significantly outperformed the more naive $\vec { v }$ -Net approach.
+
+Furthermore, we investigated stability by evaluating the evolution of $L _ { p }$ and $L _ { d }$ for the $\vec { a }$ -Net over time (see Figure 4). As the fluid state is initialized with $a _ { z } = 0$ and $p = 0$ , the $\vec { a }$ -Net has to perform a cold-start which is the reason for high $L _ { p }$ and $L _ { d }$ during the first circa 70 steps. Afterwards, the $\vec { a }$ -Net continues an accurate and stable fluid simulation.
+
+Table 1: Quantitative comparison of timesteps per second (TPS) on CPU / GPU as well as divergence loss and momentum loss for differentiable fluid solvers on a $1 0 0 \mathrm { x } 1 0 0$ grid for viscosity $\mu =$ 0.1, density $\rho = 4$ and timesteps of size $d t = 4$ .   
+
+<table><tr><td>Method</td><td>CPU[TPS]</td><td>GPU[TPS]</td><td>Ld</td><td>Lp</td></tr><tr><td>PhiFlow</td><td>7</td><td>-</td><td>6.2e-4</td><td>-</td></tr><tr><td>U-Net (ours)</td><td>82</td><td>311</td><td>8.66e-7</td><td>4.87e-5</td></tr><tr><td>α-Net (ours)</td><td>82</td><td>311</td><td>5.44e-7</td><td>1.56e-5</td></tr></table>
+
+![](images/61d33028f9c357e03bf3a26def07202e3075dc25a8368f4cd3727ad576eaeaf4.jpg)  
+Figure 4: Long term stability of fluid simulations performed by the $\vec { a }$ -Net
+
+# 4.3 OPTIMAL CONTROL OF VORTEX SHEDDING FREQUENCY
+
+In this section, we present a proof-of-concept experiment that aims at controlling the shedding frequency of a Kármán vortex street behind an obstacle by changing the flow speed (see Figure 5a). To this end, we exploit our previously trained differentiable fluid models.
+
+![](images/12287e6b64712b1dba143620da30b36d8a493efa70292097fa075f8a7596b80d.jpg)
+
+(a) control setup (domain size: $2 0 0 \mathrm { x } 1 0 0$ grid cells)
+
+![](images/eb7c6bdf57710e1d85311fd4fa94bc4129112926d9bad99da48def5bc5fb1064.jpg)  
+Figure 5: The frequency of vortex streets can be controlled using our differentiable fluid models.
+
+First, we measure the y-component of the velocity field $v _ { y } ( t )$ behind an obstacle (see white box in Figure 5a) over 200 time steps. Then, we compute the frequency spectrum $V _ { y } ( f )$ of $v _ { y } ( t )$ using the fast Fourier transform (see Figure 5b). Now, we want to adjust the inflow $/$ outflow boundary conditions in $\vec { v _ { d } }$ such that $E [ | V _ { y } ( f ) | ^ { 2 } ] = \hat { f }$ . Here, $\hat { f }$ is the target frequency. To optimize $\Vec { v _ { d } }$ , we define a loss function $L = ( E [ | V _ { y } ( f ) | ^ { 2 } ] - \hat { f } ) ^ { 2 }$ and compute the gradients $\frac { \partial L } { \partial \vec { v } _ { d } }$ with backpropagation through time. This is possible since all parts of the loss function including the fluid simulation that is performed by our trained neural fluid model as well as the fast Fourier transform are differentiable. Computing the gradients with a standard automatic differentiation library (Pytorch) took 3.5 seconds for all 200 time steps on our $2 0 0 \mathrm { x } 1 0 0$ domain setup. This is considerably faster than the current state-of-the-art differentiable fluid solver by Takahashi et al. (2021) which takes 5.42 seconds for only 30 time steps on a smaller $1 2 8 \mathrm { x } 1 2 8$ grid. The update steps of $\Vec { v _ { d } }$ are done using the ADAMoptimizer and converge after approximately 70 iterations (see Figure 5c). We want to emphasize that differentiable fluid simulations are limited to scenarios with low Reynolds numbers as in the presence of turbulences, chaotic behavior will lead to exploding gradients.
+
+# 5 DISCUSSION AND OUTLOOK
+
+In this work, we present an unsupervised learning scheme for the incompressible Navier-Stokes equations and introduce a fluid model that uses a vector potential to output divergence-free velocity fields. Qualitative results of our trained fluid models are in good accordance with expectations from fluid dynamics for a wide range of Reynolds numbers and generalize to unknown fluid domains. Quantitative assessment showed superior performance in terms of accuracy and speed compared to Phiflow and an ablation study that directly predicts the velocity field. We present a real-time demo and demonstrate how differentiability can be used in a proof-of-concept fluid control scenario. We believe that our fluid models can significantly speed up more sophisticated fluid control pipelines such as described by Holl et al. (2020).
+
+First experiments of extending this approach to 3D deliver encouraging results and are topic of future research. Furthermore, on top of Dirichlet boundary conditions, Neumann boundary conditions and multi-phase domains could be incorporated in future fluid models as well.
+
+# REFERENCES
+
+Nicholas Geneva and Nicholas Zabaras. Quantifying model form uncertainty in reynolds-averaged turbulence models with bayesian deep neural networks. Journal of Computational Physics, 383: 125 – 147, 2019. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2019.01.021. URL http: //www.sciencedirect.com/science/article/pii/S0021999119300464.
+
+Nicholas Geneva and Nicholas Zabaras. Modeling the dynamics of pde systems with physicsconstrained deep auto-regressive networks. Journal of Computational Physics, 403:109056, 2020.
+
+Robert A. Gingold and Joseph J. Monaghan. Smoothed particle hydrodynamics: theory and application to non-spherical stars. Monthly notices of the royal astronomical society, 181(3): 375–389, 1977.
+
+Philipp Grohs, Fabian Hornung, Arnulf Jentzen, and Philippe Von Wurstemberger. A proof that artificial neural networks overcome the curse of dimensionality in the numerical approximation of black-scholes partial differential equations. arXiv preprint arXiv:1809.02362, 2018.
+
+Francis H. Harlow and J. Eddie Welch. Numerical calculation of time-dependent viscous incompressible flow of fluid with free surface. The physics of fluids, 8(12):2182–2189, 1965.
+
+Philipp Holl, Vladlen Koltun, and Nils Thuerey. Learning to control pdes with differentiable physics. ICLR, 2020.
+
+Yuehaw Khoo, Jianfeng Lu, and Lexing Ying. Solving for high-dimensional committor functions using artificial neural networks. Research in the Mathematical Sciences, 6(1):1, 2019.
+
+Byungsoo Kim, Vinicius C. Azevedo, Nils Thuerey, Theodore Kim, Markus Gross, and Barbara Solenthaler. Deep fluids: A generative network for parameterized fluid simulations. In Computer Graphics Forum, volume 38, pp. 59–70. Wiley Online Library, 2019.
+
+Junhyuk Kim and Changhoon Lee. Deep unsupervised learning of turbulence for inflow generation at various reynolds numbers. Journal of Computational Physics, 406:109216, 2020. ISSN 0021- 9991. doi: https://doi.org/10.1016/j.jcp.2019.109216. URL http://www.sciencedirect. com/science/article/pii/S0021999119309210.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015.
+
+L’ubor Ladický, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. Datadriven fluid simulations using regression forests. ACM Trans. Graph., 34(6), October 2015. ISSN 0730-0301. doi: 10.1145/2816795.2818129. URL https://doi.org/10.1145/ 2816795.2818129.
+
+Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In ICLR, 2019.
+
+Julia Ling, Andrew Kurzawski, and Jeremy Templeton. Reynolds averaged turbulence modelling using deep neural networks with embedded invariance. Journal of Fluid Mechanics, 807:155– 166, 2016.
+
+Arvind T. Mohan, Nicholas Lubbers, Daniel Livescu, and Michael Chertkov. Embedding hard physical constraints in neural network coarse-graining of 3d turbulence, 2020.
+
+Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li Fei-Fei, Joshua B. Tenenbaum, and Daniel L. K. Yamins. Flexible neural representation for physics prediction. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, NIPS’18, pp. 8813–8824, Red Hook, NY, USA, 2018. Curran Associates Inc.
+
+Maziar Raissi, Alireza Yazdani, and George Em Karniadakis. Hidden fluid mechanics: A navierstokes informed deep learning framework for assimilating flow visualization data. arXiv preprint arXiv:1808.04327, 2018.
+
+Maziar Raissi, P. Perdikaris, and George Em Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378:686 – 707, 2019. ISSN 0021- 9991. doi: https://doi.org/10.1016/j.jcp.2018.10.045. URL http://www.sciencedirect. com/science/article/pii/S0021999118307125.
+
+Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, pp. 234–241. Springer, 2015.
+
+Connor Schenck and Dieter Fox. Spnets: Differentiable fluid dynamics for deep neural networks. In Conference on Robot Learning, pp. 317–335, 2018.
+
+Markus Schöberl, Nicholas Zabaras, and Phaedon-Stelios Koutsourelakis. Predictive collective variable discovery with deep bayesian models. The Journal of Chemical Physics, 150(2):024109, 2019. doi: 10.1063/1.5058063. URL https://doi.org/10.1063/1.5058063.
+
+Justin Sirignano and Konstantinos Spiliopoulos. Dgm: A deep learning algorithm for solving partial differential equations. Journal of Computational Physics, 375:1339 – 1364, 2018. ISSN 0021- 9991. doi: https://doi.org/10.1016/j.jcp.2018.08.029. URL http://www.sciencedirect. com/science/article/pii/S0021999118305527.
+
+Jos Stam. Stable fluids. In Proceedings of the 26th annual conference on Computer graphics and interactive techniques, pp. 121–128, 1999.
+
+Tetsuya Takahashi, Junbang Liang, Yi-Ling Qiao, and Ming C Lin. Differentiable fluids with solid coupling for learning and control. 2021.
+
+Nils Thuerey, Konstantin Weißenow, Lukas Prantl, and Xiangyu Hu. Deep learning methods for reynolds-averaged navier–stokes simulations of airfoil flows. AIAA Journal, pp. 1–12, 2019.
+
+Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating eulerian fluid simulation with convolutional networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3424–3433. JMLR. org, 2017.
+
+Rohit K. Tripathy and Ilias Bilionis. Deep uq: Learning deep neural network surrogate models for high dimensional uncertainty quantification. Journal of Computational Physics, 375:565 – 588, 2018. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2018.08.036. URL http://www. sciencedirect.com/science/article/pii/S0021999118305655.
+
+Kiwon Um, Raymond Fei, Philipp Holl, Robert Brand, and Nils Thuerey. Solver-in-the-loop: Learning from differentiable physics to interact with iterative pde-solvers, 2020.
+
+Benjamin Ummenhofer, Lukas Prantl, Nils Thuerey, and Vladlen Koltun. Lagrangian fluid simulation with continuous convolutions. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?id $=$ B1lDoJSYDH.
+
+You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. Tempogan: A temporally coherent, volumetric gan for super-resolution fluid flow. ACM Trans. Graph., 37(4), July 2018. ISSN 0730-0301. doi: 10.1145/3197517.3201304. URL https://doi.org/10.1145/3197517.3201304.
+
+Cheng Yang, Xubo Yang, and Xiangyun Xiao. Data-driven projection method in fluid simulation. Computer Animation and Virtual Worlds, 27(3-4):415–424, 2016. doi: 10.1002/cav.1695. URL https://onlinelibrary.wiley.com/doi/abs/10.1002/cav.1695.
+
+Yinhao Zhu and Nicholas Zabaras. Bayesian deep convolutional encoder–decoder networks for surrogate modeling and uncertainty quantification. Journal of Computational Physics, 366:415 – 447, 2018. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2018.04.018. URL http: //www.sciencedirect.com/science/article/pii/S0021999118302341.
+
+Yinhao Zhu, Nicholas Zabaras, Phaedon-Stelios Koutsourelakis, and Paris Perdikaris. Physicsconstrained deep learning for high-dimensional surrogate modeling and uncertainty quantification without labeled data. Journal of Computational Physics, 394:56 – 81, 2019. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2019.05.024. URL http://www.sciencedirect.com/ science/article/pii/S0021999119303559.
+
+# A PHYSICS-CONSTRAINED LOSS ON A MAC GRID
+
+As mentioned in Section 3.3 of the paper, our method relies on a staggered marker-and-cell grid representation for the vector potential as well as the velocity and pressure fields. In the following, we provide further details on how to apply this representation to learn incompressible fluid dynamics.
+
+To calculate the velocity field $\vec { v } = \nabla \times \vec { a }$ of a vector potential $\vec { a }$ on a MAC grid in 2D, we have to compute the curl as follows:
+
+$$
+\begin{array} { r } { ( v _ { x } ) _ { i , j } = ( a _ { z } ) _ { i + 1 , j } - ( a _ { z } ) _ { i , j } } \\ { ( v _ { y } ) _ { i , j } = ( a _ { z } ) _ { i , j } - ( a _ { z } ) _ { i , j + 1 } } \end{array}
+$$
+
+If this vector potential is inserted into the divergence operator on a MAC grid, we can show that $\nabla \cdot \vec { v } _ { i , j } = 0$ is indeed fulfilled:
+
+$$
+\begin{array} { r l } & { \nabla \cdot \vec { v } _ { i , j } = ( { v } _ { x } ) _ { i , j + 1 } - ( { v } _ { x } ) _ { i , j } + ( { v } _ { y } ) _ { i + 1 , j } - ( { v } _ { y } ) _ { i , j } } \\ & { \qquad = \begin{array} { r l } & { ( ( a _ { z } ) _ { i + 1 , j + 1 } - ( a _ { z } ) _ { i , j + 1 } ) - ( ( a _ { z } ) _ { i + 1 , j } - ( a _ { z } ) _ { i , j } ) } \\ & { \qquad + \left( ( a _ { z } ) _ { i + 1 , j } - ( a _ { z } ) _ { i + 1 , j + 1 } \right) - ( ( a _ { z } ) _ { i , j } - ( a _ { z } ) _ { i , j + 1 } ) } \\ & { \qquad = 0 } \end{array} } \end{array}
+$$
+
+Thus, for the $\vec { a }$ -Net, the incompressibility equation is automatically fulfilled and no further training on the divergence loss $L _ { d }$ is required. However, for the $\vec { v }$ -Net, the residuals of the divergence are still of importance:
+
+$$
+( R _ { d } ) _ { i , j } ^ { t + d t } = \nabla \cdot \vec { v } _ { i , j } ^ { t + d t } ( = 0 \mathrm { f o r } \vec { a } \ – \mathrm { N e t } )
+$$
+
+The residuals of the momentum equation in $x$ -direction can be computed as follows:
+
+$$
+\begin{array} { r l } & { { R _ { p _ { x } } } ) _ { i , j } ^ { t + d t } = \rho ( \frac { ( v _ { x } ) _ { i , j } ^ { t + d t } - ( v _ { x } ) _ { i , j } ^ { t } } { d t } + ( v _ { x } ) _ { i , j } ^ { t ^ { \prime } } \cdot \frac { ( v _ { x } ) _ { i , j + 1 } ^ { t ^ { \prime } } - ( v _ { x } ) _ { i , j - 1 } ^ { t ^ { \prime } } } { 2 }  } \\ & { \qquad +  \frac { \frac { ( v _ { y } ) _ { i , j - 1 } ^ { t ^ { \prime } } + ( v _ { y } ) _ { i , j } ^ { t ^ { \prime } } } { 2 } \cdot ( ( v _ { x } ) _ { i , j } ^ { t ^ { \prime } } - ( v _ { x } ) _ { i - 1 , j } ^ { t ^ { \prime } } ) + \frac { ( v _ { y } ) _ { i + 1 , j - 1 } ^ { t ^ { \prime } } + ( v _ { y } ) _ { i + 1 , j } ^ { t ^ { \prime } } } { 2 } \cdot ( ( v _ { x } ) _ { i + 1 , j } ^ { t ^ { \prime } } - ( v _ { x } ) _ { i , j } ^ { t ^ { \prime } }  } {   ( \frac { 1 } { 2 }  }   } \\ & { \qquad +     ( p _ { i , j } ^ { t + d t } - p _ { i , j - 1 } ^ { t + d t } ) - \mu \cdot \Delta ( v _ { x } ) _ { i , j } ^ { t ^ { \prime } }   } \end{array}
+$$
+
+Here, we use the following isotropic Laplace operator:
+
+$$
+\begin{array} { c } { \Delta s _ { i , j } = \displaystyle \frac { 1 } { 4 } ( 1 * s _ { i - 1 , j - 1 } + 2 * s _ { i - 1 , j } + 1 * s _ { i - 1 , j + 1 } } \\ { + 2 * s _ { i , j - 1 } - 1 2 * s _ { i , j } + 2 * s _ { i , j + 1 } } \\ { + 1 * s _ { i + 1 , j - 1 } + 2 * s _ { i + 1 , j } + 1 * s _ { i + 1 , j + 1 } ) } \end{array}
+$$
+
+The derivation of the advection term for $R _ { p _ { x } }$ is a bit more complex since on a MAC grid, $v _ { x }$ and $v _ { y }$ are displaced by half a pixel in $x$ -direction and $y$ -direction. To obtain the residuals of the momentum equation in $y$ -direction, $( R _ { p _ { y } } ) _ { i , j }$ , one has to take $( R _ { p _ { x } } ) _ { i , j }$ and swap $x$ and $y$ and the indices respectively.
+
+Now, the discretized loss terms can be written as follows:
+
+$$
+\begin{array} { l } { { { \cal L } _ { d } ^ { t + d t } = \displaystyle \sum _ { i , j } \Omega _ { i , j } ^ { t + d t } ( ( R _ { d } ) _ { i , j } ^ { t + d t } ) ^ { 2 } } } \\ { { { \cal L } _ { p } ^ { t + d t } = \displaystyle \sum _ { i , j } \Omega _ { i , j } ^ { t + d t } \left( ( ( R _ { p _ { x } } ) _ { i , j } ^ { t + d t } ) ^ { 2 } + ( ( R _ { p _ { y } } ) _ { i , j } ^ { t + d t } ) ^ { 2 } \right) } } \\ { { { \cal L } _ { b } ^ { t + d t } = \displaystyle \sum _ { i , j } \partial \Omega _ { i , j } ^ { t + d t } \left. \vec { v } _ { d } ^ { t + d t } - \vec { v } ^ { t + d t } \right. ^ { 2 } } } \end{array}
+$$
+
+Note, that all mentioned operations can be efficiently implemented with convolutions. To obtain the final velocities on a square grid, we project the velocity fields of the MAC grid back onto the $\vec { a }$ -grid using linear interpolation:
+
+$$
+\vec { v } = \frac { 1 } { 2 } \left( { ( v _ { x } ) _ { i - 1 , j } } + { ( v _ { x } ) _ { i , j } } \right)
+$$
+
+# B NETWORK ARCHITECTURE
+
+Our fluid model is based on the U-Net architecture (Ronneberger et al. (2015)) with fewer channels (see Figure 6). As the pressure field and vector potential can have an arbitrary offset, we always normalize the mean of the pressure $( \Delta p )$ and vector potential $( \Delta a _ { z } )$ to 0 to keep these fields welldefined and prevent drifting offset values.
+
+![](images/a1472214f77f3cafefb7b390de489bc06eea4b6ab22438d1c71d7d3ffc0cd1ea.jpg)  
+Figure 6: U-Net architecture with fewer channels.
+
+# C EXAMPLES OF TRAINING DOMAINS
+
+The domains we used for training consist of $1 0 0 \times 3 0 0$ grids. We used 3 different randomized domains as exemplary depicted in Figure 7. First, we have boxes with randomized height and width that float on randomized paths inspired by Brownian motion in a pipe with randomized flow speed. Second, we have the same setup but replaced the boxes by cylinders with randomized radii and angular velocities in order to learn the Magnus effect. Finally, we have a folded pipe system with randomized flow speed, that is randomly flipped along the $x$ -axis.
+
+# D FURTHER EXAMPLES OF GENERALIZATION
+
+Note that the network was only trained on simple domain geometries as presented in appendix C. Still, as can be seen in Figure 8, the network is capable of generalizing to far more complicated domain geometries (e.g. shark, car). Figure 8c shows that it can generalize to multiple objects in the scene, although the training set contained at most one object per scene. And Figure 8d shows that we can alter the outer boundary conditions as well. For real-time simulations, please have a look at our source code and the supplementary video.
+
+# E QUANTITATIVE ANALYSIS: THE BENCHMARK PROBLEM
+
+Figure 9 shows the domain $\Omega$ and $v _ { d }$ on a $1 0 0 \times 1 0 0$ grid which was used as the benchmark problem for quantitative analysis. The flow speed for the inlet and outlet was set to 0.5. The timestep of the integrator was set to $d t = 4$ and the viscosity and fluid density were set to $\mu = 0 . 1$ and $\rho = 4$ respectively.
+
+![](images/0679b34b9e40dd6fbcd896e5dfe9d2350e866f3fa97de7241da416b4cf20acb7.jpg)  
+Figure 7: The left column shows $\Omega$ (in white) / $\partial \Omega$ (in black) and the right column shows $\vec { v _ { d } }$ for three examples of training domains. (Colors indicate the direction and magnitude of $\vec { v _ { d } }$ as depicted in Figure 9a)
+
+![](images/96b4681cd4da05c85f6888b7d4f74625dfc620d8aa2ce10458c046f72e55cfd8.jpg)  
+Figure 8: Our models generalize to various domain geometries, although being trained only on simple shapes (see Figure 7)
+
+# F QUALITATIVE COMPARISON OF $\vec { a }$ -NET AND $\vec { v }$ -NET
+
+We give a qualitative example to show the benefits of using a vector potential. Figure 10 demonstrates that the $\vec { a }$ -Net finds plausible solutions for a folded pipe domain while the $\vec { v }$ -Net looses most of the flow in the center of the domain. This is in good accordance with quantitative results shown in section 1. The folded pipe domain is particularly difficult to learn as the flow field contains long range dependencies to the inlet and outlet (as shown in the bottom row in Figure 7).
+
+# G TRAINING WITHOUT RESETTING ENVIRONMENTS
+
+We performed an ablation study to investigate what happens if we do not reset old environments from time to time and, thus, do not continuously present the fluid model with cold starts during training. Figure 11 shows that in this case, large error spikes appear in the validation curve. These error spikes appear since the model has troubles to perform a cold start as can be seen in Figure 11b: compared to a properly trained model (see Figure 4) the model takes longer to perform a cold start (ca 100 steps) and converges to a solution with high $L _ { p }$ - and $L _ { d } .$ - losses. By resetting the environments from time to time during training, we can prevent these error spikes as shown in Figure 11c.
+
+![](images/7ef32d47da39bc6f2709e48b8263109e11b93a309f24cdd7e9700f02552db9ad.jpg)  
+Figure 9: a) shows legend for $\scriptstyle { \vec { v _ { d } } }$ ; b) shows $\Omega$ (in white) $/ \partial \Omega$ (in black) for the benchmark problem; c) shows $\vec { v _ { d } }$ for the benchmark problem. (Colors indicate the direction of $\vec { v _ { d } }$ as depicted in a)
+
+![](images/c6c35a94812aee60c202ac85d9e3bb29901144c51d0e016529668a2acd428f16.jpg)  
+Figure 10: Qualitative comparison of $\vec { a }$ -Net and $\vec { v }$ -Net in a folded pipe domain
+
+![](images/e9613f5f266dea5d70e2be191186fc22a58c75552972d2b5b6f43b06f8bbc705.jpg)  
+Figure 11: a) ablation study without resetting environments: validation curve shows large error spikes during training; b) error spike: the fluid model takes longer to perform a cold start and converges to a solution with high losses; c) original training with resetting environments: validation curve is stable

parse/train/KUDUoRsEphu/KUDUoRsEphu_content_list.json

@@ -0,0 +1,1861 @@
+[
+    {
+        "type": "text",
+        "text": "LEARNING INCOMPRESSIBLE FLUID DYNAMICS FROM SCRATCH - TOWARDS FAST, DIFFERENTIABLE FLUID MODELS THAT GENERALIZE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            823,
+            171
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Nils Wandel   \nDepartment of Computer Science University of Bonn   \nwandeln@cs.uni-bonn.de   \nMichael Weinmann   \nDepartment of Computer Science   \nUniversity of Bonn   \nmw@cs.uni-bonn.de   \nReinhard Klein   \nDepartment of Computer Science   \nUniversity of Bonn   \nrk@cs.uni-bonn.de ",
+        "bbox": [
+            184,
+            194,
+            405,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            593,
+            194,
+            813,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            272,
+            405,
+            328
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            364,
+            544,
+            380
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fast and stable fluid simulations are an essential prerequisite for applications ranging from computer-generated imagery to computer-aided design in research and development. However, solving the partial differential equations of incompressible fluids is a challenging task and traditional numerical approximation schemes come at high computational costs. Recent deep learning based approaches promise vast speed-ups but do not generalize to new fluid domains, require fluid simulation data for training, or rely on complex pipelines that outsource major parts of the fluid simulation to traditional methods. ",
+        "bbox": [
+            233,
+            396,
+            764,
+            507
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a novel physics-constrained training approach that generalizes to new fluid domains, requires no fluid simulation data, and allows convolutional neural networks to map a fluid state from time-point $t$ to a subsequent state at time $t + d t$ in a single forward pass. This simplifies the pipeline to train and evaluate neural fluid models. After training, the framework yields models that are capable of fast fluid simulations and can handle various fluid phenomena including the Magnus effect and Kármán vortex streets. We present an interactive real-time demo to show the speed and generalization capabilities of our trained models. Moreover, the trained neural networks are efficient differentiable fluid solvers as they offer a differentiable update step to advance the fluid simulation in time. We exploit this fact in a proof-of-concept optimal control experiment. Our models significantly outperform a recent differentiable fluid solver in terms of computational speed and accuracy. ",
+        "bbox": [
+            233,
+            511,
+            764,
+            690
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            718,
+            336,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Simulating the behavior of fluids by solving the incompressible Navier-Stokes equations is of great importance for a wide range of applications and accurate as well as fast fluid simulations are a long-standing research goal. On top of simulating the behavior of fluids, several applications such as sensitivity analysis of fluids or gradient-based control algorithms rely on differentiable fluid simulators that allow to propagate gradients throughout the simulation (Holl et al. (2020)). ",
+        "bbox": [
+            174,
+            750,
+            823,
+            819
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent advances in deep learning aim for fast and accurate fluid simulations but rely on vast datasets and / or do not generalize to new fluid domains. Kim et al. (2019) present a framework to learn parameterized fluid simulations and allow to interpolate efficiently in between such simulations. However, their work does not generalize to new domain geometries that lay outside the training data. Kim & Lee (2020) train a RNN-GAN that produces turbulent flow fields within a pipe domain, but do not show generalization results beyond pipe domains. Xie et al. (2018) introduce a tempoGAN to perform temporally consistent superresolution of smoke simulations. This allows to produce plausible high-resolution smoke-density fields for arbitrary low-resolution inputs, but our fluid model should output a complete fluid state description consisting of a velocity and a pressure field. Tompson et al. (2017) present how a Helmholtz projection step can be learned to accelerate Eulerian fluid simulations. This method generalizes to new domain geometries, but a particle tracer is needed to deal with the advection term of the Navier-Stokes equations. Furthermore, as Eulerian fluids do not model viscosity, effects like e.g. the Magnus effect or Kármán vortex streets cannot be simulated. Geneva & Zabaras (2020) propose a physics-informed framework to learn the entire update step for the Burgers equations in 1D and 2D, but no generalization results for new domain geometries are demonstrated. All of the aforementioned methods rely on the availability of vast amounts of data from fluid-solvers such as FEniCS, OpenFOAM or Mantaflow. Most of these methods do not generalize well or outsource a major part of the fluid simulation to traditional methods such as low-resolution fluid solvers or a particle tracer. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            270
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we propose a novel unsupervised training framework to learn incompressible fluid dynamics from scratch. It does not require any simulated fluid-data (neither as ground truth data, nor to train an adversarial network, nor to initialize frames for a physics-constrained loss) and generalizes to fluid domains unseen during training. It allows CNNs to learn the entire update-step of mapping a fluid domain from time-point $t$ to $t + d t$ without having to rely on low resolution fluid-solvers or a particle-tracer. In fact, we will demonstrate that a physicsconstrained loss function combined with a simple strategy to recycle fluid-data generated by the neural network at training time suffices to teach CNNs fluid dynamics on increasingly realistic statistics of fluid states. This drastically simplifies the training pipeline. Fluid simulations get efficiently unrolled in time by recurrently applying the trained model on a fluid state. Furthermore, the fluid models include viscous friction and handle effects such as the Magnus effect and Kármán vortex streets. On top of that, we show by a gradient-based optimal control example how backpropagation through time can be used to differentiate the fluid simulation. Code and pretrained models are publicly available at https://github.com/aschethor/ Unsupervised_Deep_Learning_of_Incompressible_Fluid_Dynamics/. ",
+        "bbox": [
+            174,
+            277,
+            825,
+            486
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            505,
+            344,
+            521
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In literature, several different approaches can be found that aim to approximate the dynamics of PDEs in general and fluids in particular with efficient, learning-based surrogate models. ",
+        "bbox": [
+            174,
+            537,
+            823,
+            565
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Lagrangian methods such as smoothed particle hydrodynamcs (SPH) Gingold & Monaghan (1977) handle fluids from the perspective of many individual particles that move with the velocity field. Following this approach, learning-based methods using regression forests by Ladický et al. (2015), graph neural networks by Mrowca et al. (2018); Li et al. (2019) and continuous convolutions by Ummenhofer et al. (2020) have been developed. In addition, Smooth Particle Networks (SP-Nets) by Schenck & Fox (2018) allow for differentiable fluid simulations within the Lagrangian frame of reference. These Lagrangian methods are particularly suitable when a fluid domain exhibits large, dynamic surfaces (e.g. waves or droplets). However, to simulate the dynamics within a fluid domain accurately, Eulerian methods, that treat the Navier-Stokes equations in a fixed frame of reference, are usually better suited. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            712
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Continuous Eulerian methods allow for mesh-free solutions by mapping domain coordinates (e.g. $x , y , t )$ directly onto field values (e.g. velocity $\\vec { v } \\ : /$ pressure $p$ ) (Sirignano & Spiliopoulos (2018); Grohs et al. (2018); Khoo et al. (2019)). Recent applications focused on flow through porous media (Zhu & Zabaras (2018); Zhu et al. (2019); Tripathy & Bilionis (2018)), fluid modeling (Yang et al. (2016); Raissi et al. (2018)), turbulence modeling (Geneva & Zabaras (2019); Ling et al. (2016)) and modeling of molecular dynamics (Schöberl et al. (2019)). Training is usually based on physics-constrained loss functions that penalize residuals of the underlying PDEs. Similar to our approach, Raissi et al. (2019) uses vector potentials to obtain continuous divergence-free velocity fields to approximate the incompressible Navier-Stokes equations. Continuous methods return smooth, accurate results and can overcome the curse of dimensionality of discrete techniques in high-dimensional PDEs (Grohs et al. (2018)). However, these networks are trained on a specific domain and cannot generalize to new environments or be used in interactive scenarios. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            885
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Discrete Eulerian methods, on the other hand, aim to solve the underlying PDEs on a grid and early work dates back to Harlow & Welch (1965) and Stam (1999). Accelerating such traditional works with deep learning techniques is a major field of research and all of the methods mentioned in the introduction fall into this category. Further methods include the approach by Thuerey et al. (2019) to learn solutions of the Reynolds-averaged Navier-Stokes equations for airfoil flows, but requires large amounts of training data and does not generalize beyond airfoil flows. In the work by Um et al. (2020), a correction step is learned that brings solutions of a low-resolution differentiable fluid solver closer to solutions of a high-resolution fluid simulation. However, generalization results for new domain geometries were not presented. The works of Mohan et al. (2020) and Kim et al. (2019) show that vector potentials are suitable to enforce the incompressibility constraint in fluids but do not generalize to new fluid domains beyond their training data. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            276,
+            282,
+            292
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we briefly review the incompressible Navier-Stokes equations, which are to be solved by the neural network. Then, we explain how the Helmholtz decomposition can be exploited to ensure incompressibility within the fluid domain. Furthermore, we provide details of our discrete spatio-temporal fluid representation and introduce the fluid model. Afterwards, we formulate a physics-constrained loss function based on residuals of the Navier-Stokes equations and introduce a pressure regularization term for very high Reynolds numbers. Finally, we explain the unsupervised training strategy. ",
+        "bbox": [
+            174,
+            308,
+            825,
+            406
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 INCOMPRESSIBLE NAVIER-STOKES EQUATIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            421,
+            545,
+            436
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Most fluids can be modeled with the incompressible Navier-Stokes equations - a set of non-linear equations that describe the interplay of a velocity field $\\vec { v }$ and a pressure field $p$ within a fluid domain $\\Omega$ : ",
+        "bbox": [
+            174,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c2739be49bcb70d4e71989d437fa9dc175763d8b140a742b3353373fd1da5aa6.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\boldsymbol { \\nabla } \\cdot \\boldsymbol { \\vec { v } } = 0 } & { \\mathrm { i n c o m p r e s s i b i l i t y ~ o n ~ } \\Omega } \\\\ { \\rho \\dot { \\vec { v } } = \\rho \\left( \\frac { \\partial \\vec { v } } { \\partial t } + \\left( \\vec { v } \\cdot \\boldsymbol { \\nabla } \\right) \\vec { v } \\right) = - \\boldsymbol { \\nabla } p + \\mu \\Delta \\vec { v } + \\vec { f } } & { \\mathrm { c o n s e r v a t i o n ~ o f ~ m o m e n t u m ~ o n ~ } \\Omega } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            200,
+            513,
+            774,
+            571
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\rho$ describes the fluid density and $\\mu$ the viscosity. Equation 1 states that the fluid is incompressible and thus $\\vec { v }$ is divergence-free. Equation 2 states that the change in momentum of fluid particles must correspond to the sum of forces that arise from the pressure gradient, viscous friction and external forces. Here, external forces on the fluid (such as e.g. gravity) can be neglected, so we set ${ \\vec { f } } = 0$ . ",
+        "bbox": [
+            174,
+            574,
+            825,
+            646
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "These incompressible Navier-Stokes equations shall be solved by a CNN given initial conditions $\\vec { v } ^ { 0 }$ and $p ^ { 0 }$ at the beginning of the simulation and Dirichlet boundary conditions which constrain the velocity field at the domain boundary $\\partial \\Omega$ : ",
+        "bbox": [
+            176,
+            654,
+            823,
+            695
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/382b2c7eff65cdde5b09533719fcbe295bfe23f03b98979e602e16522a1b6084.jpg",
+        "text": "$$\n\\vec { v } = \\vec { v } _ { d } \\qquad \\mathrm { D i r i c h l e t ~ b o u n d a r y ~ c o n d i t i o n ~ o n ~ } \\partial \\Omega\n$$",
+        "text_format": "latex",
+        "bbox": [
+            294,
+            700,
+            699,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 HELMHOLTZ DECOMPOSITION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            733,
+            428,
+            748
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A common method to ensure incompressibility of a fluid (see Equation 1) is to project the flow field onto the divergence-free part of its Helmholtz decomposition. The Helmholtz theorem states that every vector field $\\vec { v }$ can be decomposed into a curl-free part $( \\nabla q )$ and a divergence-free part $( \\nabla \\times \\vec { a } )$ : ",
+        "bbox": [
+            174,
+            758,
+            823,
+            803
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5d37c1b17de1cc04d458fc63441646666d5fed6f98220fdcdde403f6afb38e4d.jpg",
+        "text": "$$\n\\vec { v } = \\nabla q + \\nabla \\times \\vec { a }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            808,
+            558,
+            824
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note, that $\\nabla \\times ( \\nabla q ) = \\vec { 0 }$ and $\\nabla \\cdot ( \\nabla \\times { \\vec { a } } ) = 0$ . The Helmholtz projection consists of solving the Poisson problem $\\nabla \\cdot \\vec { v } = \\Delta q$ for $q$ , followed by substracting $\\nabla q$ from the original flow field. However, solving the Poisson equation on arbitrary domains comes at high computational costs for classical methods and one has to rely e.g. on conjugate gradient methods to approximate its solution. ",
+        "bbox": [
+            174,
+            830,
+            823,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Here, we propose a different approach and directly try to learn a vector potential $\\vec { a }$ with $\\vec { v } = \\nabla \\times \\vec { a }$ . This ensures that the network outputs a divergence-free velocity field within the domain $\\Omega$ and automatically solves Equation 1. In this work, we consider 2D fluid simulations, so only the $\\mathbf { Z }$ - component of $\\vec { a }$ , $a _ { z }$ , is of interest since $v _ { z }$ and all derivatives with respect to the $z$ -axis are zero: ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            102,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e9bd2999fb9a6c2122ff0c0f5828b5f9ab50ac874726e203ce7b01db9ed3ba1a.jpg",
+        "text": "$$\n\\nabla \\times { \\vec { a } } = \\left( { \\partial _ { z } a _ { x } - \\partial _ { z } a _ { y } } \\right) = \\left( { \\partial _ { y } a _ { z } } \\right) = \\left( { \\begin{array} { c } { v _ { x } } \\\\ { v _ { y } } \\\\ { 0 } \\end{array} } \\right) = { \\vec { v } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            138,
+            684,
+            184
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 DISCRETE SPATIO-TEMPORAL FLUID REPRESENTATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            198,
+            599,
+            214
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Marker-And-Cell (MAC) grid To solve the Navier-Stokes equations, we represent the relation between $a _ { z } , v _ { x } , v _ { y } , p$ on a 2D staggered marker-and-cell (MAC) grid (see Figure 1a). Therefore, we discretise time and space as follows: ",
+        "bbox": [
+            173,
+            224,
+            826,
+            267
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/aab624e339ff56bb8238810aeeac252a575df0efa30f328028aa0967a54307b7.jpg",
+        "text": "$$\n\\vec { a } ( x , y , t ) = \\left( \\begin{array} { c } { 0 } \\\\ { 0 } \\\\  \\left( a _ { z } \\right) _ { i , j } ^ { t } \\rule { 0 ex } { 5 ex } \\right) ; \\vec { v } ( x , y , t ) = \\binom { \\left( v _ { x } \\right) _ { i , j } ^ { t } } { \\left( v _ { y } \\right) _ { i , j } ^ { t } } ; p ( x , y , t ) = p _ { i , j } ^ { t } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            284,
+            720,
+            333
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Obtaining gradient, divergence, Laplace and curl operations on this grid with finite differences is straight forward and can be efficiently implemented with convolutions (see appendix A). ",
+        "bbox": [
+            173,
+            335,
+            826,
+            364
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/9b2df2899d456e4e435eca52239a4b16982712cebefb7099762ffba6f6c0e6f2.jpg",
+        "image_caption": [
+            "Figure 1: MAC grid and diagram of the fluid model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            387,
+            800,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Explicit, Implicit, Implicit-Explicit (IMEX) time integration methods The discretization of the time domain is needed to deal with the time-derivative of the velocity fiel d ∂\\~v∂t in Equation 2, which becomes: ",
+        "bbox": [
+            173,
+            647,
+            825,
+            688
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a68a0861a6a57a77e0f3cab5216cc15f4e068bb6ec9724bb4787efe7195131a5.jpg",
+        "text": "$$\n\\rho \\left( \\frac { \\vec { v } ^ { t + d t } - \\vec { v } ^ { t } } { d t } + \\left( \\vec { v } ^ { t ^ { \\prime } } \\cdot \\nabla \\right) \\vec { v } ^ { t ^ { \\prime } } \\right) = - \\nabla p ^ { t + d t } + \\mu \\Delta \\vec { v } ^ { t ^ { \\prime } } + \\vec { f }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            685,
+            697,
+            722
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The goal is to take as large as possible timesteps $d t$ while maintaining stable and accurate solutions. Stability and accuracy largely depend on the definition of $v ^ { t ^ { \\prime } }$ . In literature, choosing $\\boldsymbol { v } ^ { t ^ { \\prime } } = \\boldsymbol { v } ^ { t }$ is often referred to as explicit integration methods and frequently leads to unstable behavior. Choosing $v ^ { t ^ { \\prime } } = v ^ { t + d t }$ is usually associated with implicit integration methods and gives stable solutions at the cost of numerical dissipation. Implicit-Explicit (IMEX) methods, which set $v ^ { t ^ { \\prime } } = ( v ^ { t } + v ^ { t + d t } ) / 2$ are a compromise between both methods and considered to be more accurate but less stable than implicit methods. ",
+        "bbox": [
+            173,
+            729,
+            826,
+            835
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 FLUID MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            316,
+            117
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We represent the fluid dynamics by a recurrent model that maps the fluid state $p ^ { t } , \\vec { a } ^ { t }$ for timestep $t$ and the domain description $\\Omega ^ { t + d t } , \\vec { v } _ { d } ^ { t + d t }$ to the fluid state $p ^ { t + d t } , \\vec { a } ^ { t + d t }$ of the next timestep. Here, $p ^ { t }$ describes the pressure field and $\\vec { a } ^ { t }$ describes the vector potential of . For $t = 0$ , we consider initial states $p ^ { 0 } = 0$ and $\\vec { a } ^ { 0 } = \\vec { 0 }$ , however, other initial conditions could be considered as well. $\\Omega ^ { t + d t }$ is a binary mask that contains the domain geometry and is 1 for the fluid domain and 0 everywhere else. For the boundary of the domain, we simply take the inverse of $\\Omega \\colon \\partial \\Omega = 1 - \\Omega$ . $\\vec { v } _ { d } ^ { t + \\dot { d } t }$ represents the Dirichlet boundary conditions and contains a velocity field that must be matched by ${ \\vec { v } } ^ { t + d t }$ at the domain boundaries. Figure 1b shows a diagram of the fluid model. First, $\\left( p ^ { t } , \\vec { a } ^ { t } , \\Omega ^ { t + d t } , \\vec { v } _ { d } ^ { t + d t } \\right)$ are taken to derive a slightly more meaningful feature representation that comprises $\\left( p ^ { t } , a ^ { t } , \\nabla \\times a ^ { t } , \\Omega ^ { t + d t } , \\partial \\Omega ^ { t + d t } , \\Omega ^ { t + d t } \\cdot \\nabla \\times a ^ { t } , \\Omega ^ { t + d t } \\cdot p ^ { t } , \\partial \\Omega ^ { t + d t } \\cdot \\vec { v } _ { d } ^ { t + d t } \\right)$ . These features can be very efficiently computed with convolutions and are then fed into a U-Net (Ronneberger et al. (2015)) with a reduced number of channels (the exact network configuration can be found in appendix B). The mean of the U-Net output is set to 0 in order to keep $p$ and $\\vec { a }$ well defined and prevent drifting offset values. Finally, the output is added to $p ^ { t }$ and $\\vec { a } ^ { t }$ to obtain the updated fluid state $p ^ { t + d t }$ and $\\vec { a } ^ { t + d t }$ . ",
+        "bbox": [
+            173,
+            130,
+            826,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.5 PHYSICS-CONSTRAINED LOSS FUNCTION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            500,
+            381
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the residuals of the Navier-Stokes equations (Equations 1 and 2), we can formulate the following loss terms on $\\Omega$ and $\\partial \\Omega$ : ",
+        "bbox": [
+            176,
+            392,
+            823,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/560a1fae369f8b42f48f2ab1f3a5be4107aa929f6c1c94893410c3404457bb26.jpg",
+        "text": "$$\n\\begin{array} { l l } { { L _ { d } = \\displaystyle { \\left\\| \\nabla \\cdot \\vec { v } \\right\\| ^ { 2 } } } } & { { \\qquad \\mathrm { ~ d i v e r g e n c e ~ l o s s ~ o n ~ } \\Omega } } \\\\ { { L _ { p } = \\displaystyle { \\left\\| \\rho \\left( \\frac { \\partial \\vec { v } } { \\partial t } + \\left( \\vec { v } \\cdot \\nabla \\right) \\vec { v } \\right) + \\nabla p - \\mu \\Delta \\vec { v } - \\vec { f } \\right\\| ^ { 2 } } } } & { { \\qquad \\mathrm { ~ m o m e n t u m ~ l o s s ~ o n ~ } \\Omega } } \\\\ { { L _ { b } = \\displaystyle { \\left\\| \\vec { v } - \\vec { v } _ { d } \\right\\| ^ { 2 } } } } & { { \\qquad \\mathrm { ~ b o u n d a r y ~ l o s s ~ o n ~ } \\partial \\Omega } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            233,
+            444,
+            767,
+            527
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Combining the described loss terms, we obtain the following loss function: ",
+        "bbox": [
+            173,
+            539,
+            665,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcc301942512405e232beefdcdc19a6dfc51ec3a8249802eb2c2216684b8ac5c.jpg",
+        "text": "$$\nL = \\alpha L _ { d } + \\beta L _ { p } + \\gamma L _ { b }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            561,
+            580,
+            579
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha , \\beta , \\gamma$ are hyperparameters that weight the contributions of the different loss terms. Note that if we use a vector potential ${ \\vec { v } } = \\nabla \\times { \\vec { a } }$ , $L _ { d } = 0$ is automatically fulfilled and we can set $\\alpha = 0$ . This loss function can be computed very efficiently with convolutions in $O ( N )$ (where $N =$ number of grid cells), whereas solving the Navier-Stokes equations explicitly would be computationally a lot more expensive. For detailed descriptions regarding the fully discretized loss-function, we refer to appendix A. ",
+        "bbox": [
+            174,
+            584,
+            825,
+            669
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.6 PRESSURE REGULARIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            418,
+            700
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For very high Reynolds numbers (see Equation 13) and inviscid flows, training becomes unstable as viscous friction cannot dissipate enough energy out of the system. This leads to unrealistic gradients in $\\vec { v }$ and $p$ . For such cases, we introduce an additional regularization term for the loss function (11) that can be traded off with $L _ { p }$ to stabilize training: ",
+        "bbox": [
+            174,
+            712,
+            823,
+            767
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f76537da61c027d6456687ae5684be73967eba203194cb361484777f2199aea9.jpg",
+        "text": "$$\nL _ { r } = \\| \\nabla p \\| ^ { 2 }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            454,
+            775,
+            544,
+            795
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The intuition behind this regularization term is, that we want to penalize unrealistically high energies in the pressure field. ",
+        "bbox": [
+            171,
+            801,
+            825,
+            830
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.7 TRAINING STRATEGY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            364,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training starts with initializing a pool $\\{ \\Omega _ { k } ^ { 0 } , ( v _ { d } ) _ { k } ^ { 0 } , ( a _ { z } ) _ { k } ^ { 0 } , p _ { k } ^ { 0 } \\}$ of randomized domains $\\Omega _ { k } ^ { 0 }$ and boundary conditions $( v _ { d } ) _ { k } ^ { 0 }$ as well as initial conditions for the vector potential and pressure fields that we both set to zero $( \\check { ( a _ { z } ) } _ { k } ^ { 0 } = 0$ and $p _ { k } ^ { 0 } = 0$ ). The resolution of our training domains is $1 0 0 \\mathrm { x } 3 0 0$ grid cells and example-domains of the training pool are shown in appendix C. Note that our training pool does not rely on any previously simulated fluid-data. ",
+        "bbox": [
+            174,
+            128,
+            825,
+            200
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At each training step, a random mini-batch $\\{ \\Omega _ { k } ^ { t } , ( v _ { d } ) _ { k } ^ { t } , ( a _ { z } ) _ { k } ^ { t } , p _ { k } ^ { t } \\} _ { \\{ k \\in \\operatorname * { m i n i b a t c h } \\} }$ is drawn from the pool and fed into the neural network which is designed to predict the velocity $( \\vec { v } _ { k } ^ { t + d t } = \\nabla \\times \\vec { a } _ { k } ^ { t + d t } )$ and pressure $( p _ { k } ^ { t + d t } )$ fields of the next time step. Based on a physics-constrained loss-function (Equation 11), we update the weights of the network using the Adam optimizer (Kingma & Ba (2015)). At the end of each training step, the pool is updated by replacing the old vector potential and pressure fields $( a _ { z } ) _ { k } ^ { t } , p _ { k } ^ { t }$ by the newly predicted ones $( a _ { z } ) _ { k } ^ { t + \\dot { d t } } , p _ { k } ^ { \\dot { t } + d t }$ t, pt+dtk . This recycling strategy fills the training pool with more and more realistic fluid states as the model becomes better at simulating fluid dynamics. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            313
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "From time to time, old environments of the training pool are replaced by new randomized environments and the vector potential as well as the pressure fields are reset to 0. This increases the variance of the training pool and helps the neural network to learn \"cold starts\" from \\~0-velocity and 0-pressure fields. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            377
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Besides the fluid model described above, which we denote as $\\vec { a }$ -Net in the following, we also trained an ablation model, $\\vec { v }$ -Net, that directly learns to predict the velocity field without a vector potential. For the implementation of both models, we used the popular machine learning framework Pytorch and trained the models on a NVidia GeForce RTX 2080 Ti. Training converged after about 1 day. The hyperparameters in the loss-function for the $\\vec { a }$ -Net were $\\beta = 1$ and $\\gamma = 2 0$ . The reason for choosing a higher weight for the loss term $L _ { b }$ than for $L _ { p }$ was the observation, that errors in $L _ { b }$ can lead to unrealistic flows leaking through boundaries. For the ablation study $\\vec { v } \\cdot \\vec { }$ -Net), we used $\\alpha = 1 0 0 , \\beta = 1 , \\gamma = 0 . 0 0 1$ . Here, we had to choose a very high weight for $L _ { d }$ to ensure incompressibility of the fluid, otherwise unrealistic source and sink effects start to appear. For $L _ { b }$ , on the other hand, we used a very low weight as the boundary conditions can be trivially learned by the $\\vec { v }$ -Net. We used these parameter settings for all experiments. ",
+        "bbox": [
+            174,
+            383,
+            825,
+            536
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            559,
+            281,
+            575
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the potential of our method, we assess its ability to reproduce physical effects such as Kármán vortex streets and the Magnus effect. In addition, we demonstrate its generalization capability and real-time performance. Finally, we test the fluid models quantitatively. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            635
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 QUALITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            654,
+            405,
+            667
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Qualitative analysis of wake dynamics Qualitative effects in fluid dynamics such as the wake dynamics behind an obstacle are closely related to the Reynolds number. It is a dimensionless quantity defined by: ",
+        "bbox": [
+            174,
+            680,
+            825,
+            723
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4dfd04cc28aff9cd79aa9924737756fe96be62393b9e0a5e81f5954f0c177749.jpg",
+        "text": "$$\nR e = \\frac { \\rho \\left\\| \\vec { v } \\right\\| D } { \\mu }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            447,
+            723,
+            550,
+            758
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here, $\\rho$ is the fluid density, $\\lVert \\vec { v } \\rVert$ is the fluid speed, $D$ is the diameter of the obstacle, and $\\mu$ is the viscosity. (We use the units of the grid). ",
+        "bbox": [
+            173,
+            762,
+            823,
+            792
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We retrained models for different values of $\\mu$ and $\\rho$ to compare the fluid behavior for a wide range of Reynolds numbers. Figure 2 shows, that the trained models are able to predict the wake dynamics behind an obstacle in good accordance with qualitative expectations from fluid dynamics. As a rule of thumb, for $R e \\ll 1$ , the flow becomes time-reversible. This can be noticed in Figure 2a by the symmetry of the flow before and after the obstacle and the nearly constant pressure gradient within the pipe. Starting from $R e \\approx 1 0$ , the flow is still laminar but a static wake is forming behind the obstacle (see Figure 2b). For Reynolds numbers $R e > \\approx 9 0$ , Kármán vortex streets start to appear (see Figure 2c). A Kármán vortex street consists of clock and counterclockwise spinning vortices that are generated at the obstacle and then start moving in a regularly oscillating pattern with the flow. For very large Reynolds numbers or inviscid flows, the flow field becomes turbulent, which can be recognized by the irregular patterns behind the obstacle in Fig 2d. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/468c39a4bc3b15c1ad09df22f1ea2d017e585da0b07e13fdda3acc4af90342a2.jpg",
+        "image_caption": [
+            "Figure 2: After training, our models are able to show correct wake flow dynamics for a wide range of different Reynolds numbers. $\\dot { \\boldsymbol { D } } = 3 0$ , $\\| \\vec { v } \\| = 0 . 5 )$ . Streamlines indicate flow direction, linewidth indicates speed and colors represent the pressure field (blue: low pressure / yellow: high pressure). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            162,
+            789,
+            381
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Magnus effect The Magnus effect appears when a flow interacts with a rotating body. It is widely known e.g. in sports such as soccer or tennis where spin is used to deflect the path of a ball. The reason for the deflection stems from a low pressure field where the surface of the object moves along flow direction and a high pressure field where the object surface moves against the flow. Figure 3a shows, that our models are able to reproduce the Magnus effect around a rotating cylinder. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            529
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f016ae8a12c9f62a822e83f75f847c39d114a2759991e05eb174aa68cf62956a.jpg",
+        "image_caption": [
+            "(a) Magnus effect on a clock-wise turning cylinder.(b) Generalization example: Note that the fluid model has never been confronted with wingprofiles during training. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            204,
+            559,
+            790,
+            633
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: Our models feature the Magnus effect and generalize to new fluid domains. Further examples are presented in appendix D and the video. ",
+        "bbox": [
+            176,
+            690,
+            823,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Analysis of generalization capability We tested the networks capability to generalize to objects not seen during training. Figure 3b shows the networks capability to meet boundary conditions of an airfoil and return a plausible pressure field that produces lift (see low pressure on top of wing). Note that in contrast to the approach by Thuerey et al. (2019), which learns simplified, time-averaged solutions of the Navier-Stokes equations, our method is able to simulate the full incompressible Navier-Stokes equations for an airfoil without relying on any ground truth data or having seen airfoilgeometries during training. In fact, the network was only trained on simple randomized domains as highlighted in appendix C and Figure 7. Possible reasons for the networks generalization capabilities are: ",
+        "bbox": [
+            174,
+            743,
+            825,
+            868
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• During training, the network gets confronted with an infinite number of different flowfields and randomized domain configurations because the training pool gets updated at every training step. This prevents the network from over-fitting. ",
+        "bbox": [
+            217,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "• The dynamics of a fluid-particle are mostly determined by its local neighborhood / surrounding particles. This means, the update step for a certain cell on the MAC grid is mostly determined by close / neighboring MAC-grid cells. Since more complicated shapes can be seen locally as a composition of basic shapes (e.g. the front of the wing can be locally regarded as a cylinder), it suffices to train on basic shapes that provide the network with enough examples to generalize to more complicated shapes. ",
+        "bbox": [
+            217,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Further generalization examples are provided in appendix D. ",
+        "bbox": [
+            174,
+            209,
+            570,
+            223
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Real-time capability The fluid simulation can be easily parallelized and takes low computational costs as one time-integration step consists just of a single forward pass through a convolutional neural network. This enables for example interactive real-time simulations. We implemented a demo that allows to interact with a fluid by moving obstacles, rotating spheres and changing the flow speed within a pipe (see video in supplementary material and source code). Our method runs at 250 timesteps per second on a $1 0 0 \\mathrm { x } 3 0 0$ grid. In the respective experiments, we used a NVidia GeForce RTX 2080 Ti consuming about $8 6 0 \\mathrm { M B }$ of GPU memory. ",
+        "bbox": [
+            174,
+            261,
+            825,
+            358
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 QUANTITATIVE EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            397,
+            415,
+            411
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare our method $\\vec { a }$ -Net) quantitatively with PhiFlow by Holl et al. (2020). Phiflow is a recent, open source, differentiable fluid simulator based on a MAC grid data structure. Furthermore, we provide an ablation study ${ \\vec { v } } .$ -Net) that does not make use of the Helmholtz decomposition but directly works on the velocity field $\\vec { v }$ . ",
+        "bbox": [
+            174,
+            431,
+            825,
+            487
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Quantitative comparison of different fluid solvers is challenging, as their performance is highly dependent on factors like the geometry of the domain, fluid parameters such as viscosity or density, flow speed or the timestep of the integrator. As benchmarks for fluid simulations on MAC grids are not yet available, we built a simple toy domain on a $1 0 0 \\mathrm { ~ x ~ } 1 0 0$ grid which simulates a flow around an obstacle within a pipe (more details are provided in appendix E). ",
+        "bbox": [
+            174,
+            494,
+            825,
+            564
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we compared the computational speed on a CPU and GPU by comparing the integration time-steps per second (see Table 1). The $\\vec { v }$ -Net as well as the $\\vec { a }$ -Net are significantly faster than PhiFlow (11x on CPU and $4 0 \\mathrm { x }$ on GPU) as they do not rely on an iterative conjugate gradient solver but instead use a single forward pass through a convolutional neural network that can be easily parallelized on a GPU. To provide a fair comparison on $L _ { d }$ , we set the velocity field at the boundaries equal to $\\vec { v _ { d } }$ . This enables us to compute $L _ { d }$ for the $\\vec { a }$ -Net architecture on the domain boundaries which would otherwise have zero divergence everywhere. This way, $L _ { d }$ can be interpreted as a metric on how well the orthogonal components of the Dirichlet boundary conditions are met (i.e. no flow leaks through the boundaries). For $d t = 4$ , we outperformed Phiflow by several orders of magnitude. For both, $L _ { d }$ and $L _ { p }$ , the $\\vec { a }$ -Net architecture significantly outperformed the more naive $\\vec { v }$ -Net approach. ",
+        "bbox": [
+            174,
+            570,
+            825,
+            724
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, we investigated stability by evaluating the evolution of $L _ { p }$ and $L _ { d }$ for the $\\vec { a }$ -Net over time (see Figure 4). As the fluid state is initialized with $a _ { z } = 0$ and $p = 0$ , the $\\vec { a }$ -Net has to perform a cold-start which is the reason for high $L _ { p }$ and $L _ { d }$ during the first circa 70 steps. Afterwards, the $\\vec { a }$ -Net continues an accurate and stable fluid simulation. ",
+        "bbox": [
+            174,
+            731,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/57a7fb536fbdf6d2f343d51671835704f414615c5a03a13645e7d8050e19d8bb.jpg",
+        "table_caption": [
+            "Table 1: Quantitative comparison of timesteps per second (TPS) on CPU / GPU as well as divergence loss and momentum loss for differentiable fluid solvers on a $1 0 0 \\mathrm { x } 1 0 0$ grid for viscosity $\\mu =$ 0.1, density $\\rho = 4$ and timesteps of size $d t = 4$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CPU[TPS]</td><td>GPU[TPS]</td><td>Ld</td><td>Lp</td></tr><tr><td>PhiFlow</td><td>7</td><td>-</td><td>6.2e-4</td><td>-</td></tr><tr><td>U-Net (ours)</td><td>82</td><td>311</td><td>8.66e-7</td><td>4.87e-5</td></tr><tr><td>α-Net (ours)</td><td>82</td><td>311</td><td>5.44e-7</td><td>1.56e-5</td></tr></table>",
+        "bbox": [
+            200,
+            818,
+            537,
+            864
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/61d33028f9c357e03bf3a26def07202e3075dc25a8368f4cd3727ad576eaeaf4.jpg",
+        "image_caption": [
+            "Figure 4: Long term stability of fluid simulations performed by the $\\vec { a }$ -Net "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            589,
+            794,
+            813,
+            890
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 OPTIMAL CONTROL OF VORTEX SHEDDING FREQUENCY ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            609,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present a proof-of-concept experiment that aims at controlling the shedding frequency of a Kármán vortex street behind an obstacle by changing the flow speed (see Figure 5a). To this end, we exploit our previously trained differentiable fluid models. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            171
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/12287e6b64712b1dba143620da30b36d8a493efa70292097fa075f8a7596b80d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            212,
+            352,
+            282
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "(a) control setup (domain size: $2 0 0 \\mathrm { x } 1 0 0$ grid cells) ",
+        "bbox": [
+            174,
+            309,
+            356,
+            334
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb7c6bdf57710e1d85311fd4fa94bc4129112926d9bad99da48def5bc5fb1064.jpg",
+        "image_caption": [
+            "Figure 5: The frequency of vortex streets can be controlled using our differentiable fluid models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            372,
+            198,
+            818,
+            334
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First, we measure the y-component of the velocity field $v _ { y } ( t )$ behind an obstacle (see white box in Figure 5a) over 200 time steps. Then, we compute the frequency spectrum $V _ { y } ( f )$ of $v _ { y } ( t )$ using the fast Fourier transform (see Figure 5b). Now, we want to adjust the inflow $/$ outflow boundary conditions in $\\vec { v _ { d } }$ such that $E [ | V _ { y } ( f ) | ^ { 2 } ] = \\hat { f }$ . Here, $\\hat { f }$ is the target frequency. To optimize $\\Vec { v _ { d } }$ , we define a loss function $L = ( E [ | V _ { y } ( f ) | ^ { 2 } ] - \\hat { f } ) ^ { 2 }$ and compute the gradients $\\frac { \\partial L } { \\partial \\vec { v } _ { d } }$ with backpropagation through time. This is possible since all parts of the loss function including the fluid simulation that is performed by our trained neural fluid model as well as the fast Fourier transform are differentiable. Computing the gradients with a standard automatic differentiation library (Pytorch) took 3.5 seconds for all 200 time steps on our $2 0 0 \\mathrm { x } 1 0 0$ domain setup. This is considerably faster than the current state-of-the-art differentiable fluid solver by Takahashi et al. (2021) which takes 5.42 seconds for only 30 time steps on a smaller $1 2 8 \\mathrm { x } 1 2 8$ grid. The update steps of $\\Vec { v _ { d } }$ are done using the ADAMoptimizer and converge after approximately 70 iterations (see Figure 5c). We want to emphasize that differentiable fluid simulations are limited to scenarios with low Reynolds numbers as in the presence of turbulences, chaotic behavior will lead to exploding gradients. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            577
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION AND OUTLOOK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            597,
+            441,
+            612
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this work, we present an unsupervised learning scheme for the incompressible Navier-Stokes equations and introduce a fluid model that uses a vector potential to output divergence-free velocity fields. Qualitative results of our trained fluid models are in good accordance with expectations from fluid dynamics for a wide range of Reynolds numbers and generalize to unknown fluid domains. Quantitative assessment showed superior performance in terms of accuracy and speed compared to Phiflow and an ablation study that directly predicts the velocity field. We present a real-time demo and demonstrate how differentiability can be used in a proof-of-concept fluid control scenario. We believe that our fluid models can significantly speed up more sophisticated fluid control pipelines such as described by Holl et al. (2020). ",
+        "bbox": [
+            173,
+            627,
+            825,
+            753
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "First experiments of extending this approach to 3D deliver encouraging results and are topic of future research. Furthermore, on top of Dirichlet boundary conditions, Neumann boundary conditions and multi-phase domains could be incorporated in future fluid models as well. ",
+        "bbox": [
+            174,
+            760,
+            825,
+            803
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            285,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Geneva and Nicholas Zabaras. Quantifying model form uncertainty in reynolds-averaged turbulence models with bayesian deep neural networks. Journal of Computational Physics, 383: 125 – 147, 2019. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2019.01.021. URL http: //www.sciencedirect.com/science/article/pii/S0021999119300464. ",
+        "bbox": [
+            174,
+            126,
+            825,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Geneva and Nicholas Zabaras. Modeling the dynamics of pde systems with physicsconstrained deep auto-regressive networks. Journal of Computational Physics, 403:109056, 2020. ",
+        "bbox": [
+            171,
+            191,
+            823,
+            220
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Robert A. Gingold and Joseph J. Monaghan. Smoothed particle hydrodynamics: theory and application to non-spherical stars. Monthly notices of the royal astronomical society, 181(3): 375–389, 1977. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Philipp Grohs, Fabian Hornung, Arnulf Jentzen, and Philippe Von Wurstemberger. A proof that artificial neural networks overcome the curse of dimensionality in the numerical approximation of black-scholes partial differential equations. arXiv preprint arXiv:1809.02362, 2018. ",
+        "bbox": [
+            173,
+            282,
+            826,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Francis H. Harlow and J. Eddie Welch. Numerical calculation of time-dependent viscous incompressible flow of fluid with free surface. The physics of fluids, 8(12):2182–2189, 1965. ",
+        "bbox": [
+            173,
+            334,
+            820,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Philipp Holl, Vladlen Koltun, and Nils Thuerey. Learning to control pdes with differentiable physics. ICLR, 2020. ",
+        "bbox": [
+            174,
+            372,
+            821,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuehaw Khoo, Jianfeng Lu, and Lexing Ying. Solving for high-dimensional committor functions using artificial neural networks. Research in the Mathematical Sciences, 6(1):1, 2019. ",
+        "bbox": [
+            173,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Byungsoo Kim, Vinicius C. Azevedo, Nils Thuerey, Theodore Kim, Markus Gross, and Barbara Solenthaler. Deep fluids: A generative network for parameterized fluid simulations. In Computer Graphics Forum, volume 38, pp. 59–70. Wiley Online Library, 2019. ",
+        "bbox": [
+            173,
+            449,
+            826,
+            492
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Junhyuk Kim and Changhoon Lee. Deep unsupervised learning of turbulence for inflow generation at various reynolds numbers. Journal of Computational Physics, 406:109216, 2020. ISSN 0021- 9991. doi: https://doi.org/10.1016/j.jcp.2019.109216. URL http://www.sciencedirect. com/science/article/pii/S0021999119309210. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            559
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In 3rd International Conference on Learning Representations, ICLR 2015, San Diego, CA, USA, May 7-9, 2015, Conference Track Proceedings, 2015. ",
+        "bbox": [
+            176,
+            568,
+            823,
+            611
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "L’ubor Ladický, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. Datadriven fluid simulations using regression forests. ACM Trans. Graph., 34(6), October 2015. ISSN 0730-0301. doi: 10.1145/2816795.2818129. URL https://doi.org/10.1145/ 2816795.2818129. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            676
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In ICLR, 2019. ",
+        "bbox": [
+            173,
+            686,
+            823,
+            715
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Julia Ling, Andrew Kurzawski, and Jeremy Templeton. Reynolds averaged turbulence modelling using deep neural networks with embedded invariance. Journal of Fluid Mechanics, 807:155– 166, 2016. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Arvind T. Mohan, Nicholas Lubbers, Daniel Livescu, and Michael Chertkov. Embedding hard physical constraints in neural network coarse-graining of 3d turbulence, 2020. ",
+        "bbox": [
+            169,
+            776,
+            823,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li Fei-Fei, Joshua B. Tenenbaum, and Daniel L. K. Yamins. Flexible neural representation for physics prediction. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, NIPS’18, pp. 8813–8824, Red Hook, NY, USA, 2018. Curran Associates Inc. ",
+        "bbox": [
+            174,
+            814,
+            825,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maziar Raissi, Alireza Yazdani, and George Em Karniadakis. Hidden fluid mechanics: A navierstokes informed deep learning framework for assimilating flow visualization data. arXiv preprint arXiv:1808.04327, 2018. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Maziar Raissi, P. Perdikaris, and George Em Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378:686 – 707, 2019. ISSN 0021- 9991. doi: https://doi.org/10.1016/j.jcp.2018.10.045. URL http://www.sciencedirect. com/science/article/pii/S0021999118307125. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In International Conference on Medical image computing and computer-assisted intervention, pp. 234–241. Springer, 2015. ",
+        "bbox": [
+            176,
+            180,
+            823,
+            223
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Connor Schenck and Dieter Fox. Spnets: Differentiable fluid dynamics for deep neural networks. In Conference on Robot Learning, pp. 317–335, 2018. ",
+        "bbox": [
+            173,
+            229,
+            823,
+            258
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Markus Schöberl, Nicholas Zabaras, and Phaedon-Stelios Koutsourelakis. Predictive collective variable discovery with deep bayesian models. The Journal of Chemical Physics, 150(2):024109, 2019. doi: 10.1063/1.5058063. URL https://doi.org/10.1063/1.5058063. ",
+        "bbox": [
+            174,
+            265,
+            823,
+            308
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Justin Sirignano and Konstantinos Spiliopoulos. Dgm: A deep learning algorithm for solving partial differential equations. Journal of Computational Physics, 375:1339 – 1364, 2018. ISSN 0021- 9991. doi: https://doi.org/10.1016/j.jcp.2018.08.029. URL http://www.sciencedirect. com/science/article/pii/S0021999118305527. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            371
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jos Stam. Stable fluids. In Proceedings of the 26th annual conference on Computer graphics and interactive techniques, pp. 121–128, 1999. ",
+        "bbox": [
+            171,
+            376,
+            823,
+            405
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tetsuya Takahashi, Junbang Liang, Yi-Ling Qiao, and Ming C Lin. Differentiable fluids with solid coupling for learning and control. 2021. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nils Thuerey, Konstantin Weißenow, Lukas Prantl, and Xiangyu Hu. Deep learning methods for reynolds-averaged navier–stokes simulations of airfoil flows. AIAA Journal, pp. 1–12, 2019. ",
+        "bbox": [
+            173,
+            446,
+            823,
+            477
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating eulerian fluid simulation with convolutional networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 3424–3433. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            482,
+            823,
+            526
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rohit K. Tripathy and Ilias Bilionis. Deep uq: Learning deep neural network surrogate models for high dimensional uncertainty quantification. Journal of Computational Physics, 375:565 – 588, 2018. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2018.08.036. URL http://www. sciencedirect.com/science/article/pii/S0021999118305655. ",
+        "bbox": [
+            174,
+            531,
+            825,
+            588
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kiwon Um, Raymond Fei, Philipp Holl, Robert Brand, and Nils Thuerey. Solver-in-the-loop: Learning from differentiable physics to interact with iterative pde-solvers, 2020. ",
+        "bbox": [
+            176,
+            594,
+            820,
+            623
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Benjamin Ummenhofer, Lukas Prantl, Nils Thuerey, and Vladlen Koltun. Lagrangian fluid simulation with continuous convolutions. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?id $=$ B1lDoJSYDH. ",
+        "bbox": [
+            174,
+            630,
+            825,
+            686
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. Tempogan: A temporally coherent, volumetric gan for super-resolution fluid flow. ACM Trans. Graph., 37(4), July 2018. ISSN 0730-0301. doi: 10.1145/3197517.3201304. URL https://doi.org/10.1145/3197517.3201304. ",
+        "bbox": [
+            176,
+            693,
+            823,
+            736
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cheng Yang, Xubo Yang, and Xiangyun Xiao. Data-driven projection method in fluid simulation. Computer Animation and Virtual Worlds, 27(3-4):415–424, 2016. doi: 10.1002/cav.1695. URL https://onlinelibrary.wiley.com/doi/abs/10.1002/cav.1695. ",
+        "bbox": [
+            179,
+            741,
+            823,
+            785
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinhao Zhu and Nicholas Zabaras. Bayesian deep convolutional encoder–decoder networks for surrogate modeling and uncertainty quantification. Journal of Computational Physics, 366:415 – 447, 2018. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2018.04.018. URL http: //www.sciencedirect.com/science/article/pii/S0021999118302341. ",
+        "bbox": [
+            176,
+            790,
+            825,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinhao Zhu, Nicholas Zabaras, Phaedon-Stelios Koutsourelakis, and Paris Perdikaris. Physicsconstrained deep learning for high-dimensional surrogate modeling and uncertainty quantification without labeled data. Journal of Computational Physics, 394:56 – 81, 2019. ISSN 0021-9991. doi: https://doi.org/10.1016/j.jcp.2019.05.024. URL http://www.sciencedirect.com/ science/article/pii/S0021999119303559. ",
+        "bbox": [
+            176,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A PHYSICS-CONSTRAINED LOSS ON A MAC GRID",
+        "text_level": 1,
+        "bbox": [
+            173,
+            101,
+            612,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 3.3 of the paper, our method relies on a staggered marker-and-cell grid representation for the vector potential as well as the velocity and pressure fields. In the following, we provide further details on how to apply this representation to learn incompressible fluid dynamics. ",
+        "bbox": [
+            174,
+            133,
+            826,
+            176
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To calculate the velocity field $\\vec { v } = \\nabla \\times \\vec { a }$ of a vector potential $\\vec { a }$ on a MAC grid in 2D, we have to compute the curl as follows: ",
+        "bbox": [
+            174,
+            181,
+            823,
+            210
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b765b97ec27f39cb3ef2684b813a64e2db36d5b197645326fd190e5a3cb7cb1.jpg",
+        "text": "$$\n\\begin{array} { r } { ( v _ { x } ) _ { i , j } = ( a _ { z } ) _ { i + 1 , j } - ( a _ { z } ) _ { i , j } } \\\\ { ( v _ { y } ) _ { i , j } = ( a _ { z } ) _ { i , j } - ( a _ { z } ) _ { i , j + 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            217,
+            596,
+            256
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "If this vector potential is inserted into the divergence operator on a MAC grid, we can show that $\\nabla \\cdot \\vec { v } _ { i , j } = 0$ is indeed fulfilled: ",
+        "bbox": [
+            173,
+            265,
+            823,
+            295
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/27299d46665b7ad835bedbb79eebe13b79a69c1071708847f8a81582ba0fedd0.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla \\cdot \\vec { v } _ { i , j } = ( { v } _ { x } ) _ { i , j + 1 } - ( { v } _ { x } ) _ { i , j } + ( { v } _ { y } ) _ { i + 1 , j } - ( { v } _ { y } ) _ { i , j } } \\\\ & { \\qquad = \\begin{array} { r l } & { ( ( a _ { z } ) _ { i + 1 , j + 1 } - ( a _ { z } ) _ { i , j + 1 } ) - ( ( a _ { z } ) _ { i + 1 , j } - ( a _ { z } ) _ { i , j } ) } \\\\ & { \\qquad + \\left( ( a _ { z } ) _ { i + 1 , j } - ( a _ { z } ) _ { i + 1 , j + 1 } \\right) - ( ( a _ { z } ) _ { i , j } - ( a _ { z } ) _ { i , j + 1 } ) } \\\\ & { \\qquad = 0 } \\end{array} } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            299,
+            705,
+            376
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thus, for the $\\vec { a }$ -Net, the incompressibility equation is automatically fulfilled and no further training on the divergence loss $L _ { d }$ is required. However, for the $\\vec { v }$ -Net, the residuals of the divergence are still of importance: ",
+        "bbox": [
+            174,
+            388,
+            821,
+            430
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85aebe665a6f8b22e1f6ab2835d641bc59f4f38e34b69dba8879592f1bae0fbc.jpg",
+        "text": "$$\n( R _ { d } ) _ { i , j } ^ { t + d t } = \\nabla \\cdot \\vec { v } _ { i , j } ^ { t + d t } ( = 0 \\mathrm { f o r } \\vec { a } \\ – \\mathrm { N e t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            374,
+            429,
+            624,
+            450
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The residuals of the momentum equation in $x$ -direction can be computed as follows: ",
+        "bbox": [
+            173,
+            458,
+            727,
+            473
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/977088132e08193c468d875d3a44cd8ec98d7341e179d84247d2de5b4fc0cd44.jpg",
+        "text": "$$\n\\begin{array} { r l } & { { R _ { p _ { x } } } ) _ { i , j } ^ { t + d t } = \\rho ( \\frac { ( v _ { x } ) _ { i , j } ^ { t + d t } - ( v _ { x } ) _ { i , j } ^ { t } } { d t } + ( v _ { x } ) _ { i , j } ^ { t ^ { \\prime } } \\cdot \\frac { ( v _ { x } ) _ { i , j + 1 } ^ { t ^ { \\prime } } - ( v _ { x } ) _ { i , j - 1 } ^ { t ^ { \\prime } } } { 2 }  } \\\\ & { \\qquad +  \\frac { \\frac { ( v _ { y } ) _ { i , j - 1 } ^ { t ^ { \\prime } } + ( v _ { y } ) _ { i , j } ^ { t ^ { \\prime } } } { 2 } \\cdot ( ( v _ { x } ) _ { i , j } ^ { t ^ { \\prime } } - ( v _ { x } ) _ { i - 1 , j } ^ { t ^ { \\prime } } ) + \\frac { ( v _ { y } ) _ { i + 1 , j - 1 } ^ { t ^ { \\prime } } + ( v _ { y } ) _ { i + 1 , j } ^ { t ^ { \\prime } } } { 2 } \\cdot ( ( v _ { x } ) _ { i + 1 , j } ^ { t ^ { \\prime } } - ( v _ { x } ) _ { i , j } ^ { t ^ { \\prime } }  } {   ( \\frac { 1 } { 2 }  }   } \\\\ & { \\qquad +     ( p _ { i , j } ^ { t + d t } - p _ { i , j - 1 } ^ { t + d t } ) - \\mu \\cdot \\Delta ( v _ { x } ) _ { i , j } ^ { t ^ { \\prime } }   } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            478,
+            839,
+            607
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Here, we use the following isotropic Laplace operator: ",
+        "bbox": [
+            174,
+            631,
+            531,
+            646
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c608899301ad0536233808bab885c3579407cbae54d8bc518e7a673af9e5a84c.jpg",
+        "text": "$$\n\\begin{array} { c } { \\Delta s _ { i , j } = \\displaystyle \\frac { 1 } { 4 } ( 1 * s _ { i - 1 , j - 1 } + 2 * s _ { i - 1 , j } + 1 * s _ { i - 1 , j + 1 } } \\\\ { + 2 * s _ { i , j - 1 } - 1 2 * s _ { i , j } + 2 * s _ { i , j + 1 } } \\\\ { + 1 * s _ { i + 1 , j - 1 } + 2 * s _ { i + 1 , j } + 1 * s _ { i + 1 , j + 1 } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            651,
+            673,
+            719
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The derivation of the advection term for $R _ { p _ { x } }$ is a bit more complex since on a MAC grid, $v _ { x }$ and $v _ { y }$ are displaced by half a pixel in $x$ -direction and $y$ -direction. To obtain the residuals of the momentum equation in $y$ -direction, $( R _ { p _ { y } } ) _ { i , j }$ , one has to take $( R _ { p _ { x } } ) _ { i , j }$ and swap $x$ and $y$ and the indices respectively. ",
+        "bbox": [
+            173,
+            729,
+            825,
+            787
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Now, the discretized loss terms can be written as follows: ",
+        "bbox": [
+            174,
+            792,
+            550,
+            809
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c8b5a55ade2b30eea738910d0f4694d8eddab4a5166c7cb6fcb34248edd17ffd.jpg",
+        "text": "$$\n\\begin{array} { l } { { { \\cal L } _ { d } ^ { t + d t } = \\displaystyle \\sum _ { i , j } \\Omega _ { i , j } ^ { t + d t } ( ( R _ { d } ) _ { i , j } ^ { t + d t } ) ^ { 2 } } } \\\\ { { { \\cal L } _ { p } ^ { t + d t } = \\displaystyle \\sum _ { i , j } \\Omega _ { i , j } ^ { t + d t } \\left( ( ( R _ { p _ { x } } ) _ { i , j } ^ { t + d t } ) ^ { 2 } + ( ( R _ { p _ { y } } ) _ { i , j } ^ { t + d t } ) ^ { 2 } \\right) } } \\\\ { { { \\cal L } _ { b } ^ { t + d t } = \\displaystyle \\sum _ { i , j } \\partial \\Omega _ { i , j } ^ { t + d t } \\left. \\vec { v } _ { d } ^ { t + d t } - \\vec { v } ^ { t + d t } \\right. ^ { 2 } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            814,
+            669,
+            922
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Note, that all mentioned operations can be efficiently implemented with convolutions. To obtain the final velocities on a square grid, we project the velocity fields of the MAC grid back onto the $\\vec { a }$ -grid using linear interpolation: ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1eae517d940c36f0f181a8d541f42793760b25bacaefcf7eab28e5622a99d324.jpg",
+        "text": "$$\n\\vec { v } = \\frac { 1 } { 2 } \\left( { ( v _ { x } ) _ { i - 1 , j } } + { ( v _ { x } ) _ { i , j } } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            146,
+            598,
+            181
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "B NETWORK ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            199,
+            431,
+            215
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Our fluid model is based on the U-Net architecture (Ronneberger et al. (2015)) with fewer channels (see Figure 6). As the pressure field and vector potential can have an arbitrary offset, we always normalize the mean of the pressure $( \\Delta p )$ and vector potential $( \\Delta a _ { z } )$ to 0 to keep these fields welldefined and prevent drifting offset values. ",
+        "bbox": [
+            174,
+            232,
+            825,
+            287
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/a1472214f77f3cafefb7b390de489bc06eea4b6ab22438d1c71d7d3ffc0cd1ea.jpg",
+        "image_caption": [
+            "Figure 6: U-Net architecture with fewer channels. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            258,
+            301,
+            738,
+            501
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C EXAMPLES OF TRAINING DOMAINS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            556,
+            508,
+            573
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The domains we used for training consist of $1 0 0 \\times 3 0 0$ grids. We used 3 different randomized domains as exemplary depicted in Figure 7. First, we have boxes with randomized height and width that float on randomized paths inspired by Brownian motion in a pipe with randomized flow speed. Second, we have the same setup but replaced the boxes by cylinders with randomized radii and angular velocities in order to learn the Magnus effect. Finally, we have a folded pipe system with randomized flow speed, that is randomly flipped along the $x$ -axis. ",
+        "bbox": [
+            173,
+            589,
+            825,
+            674
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D FURTHER EXAMPLES OF GENERALIZATION ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            695,
+            570,
+            712
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Note that the network was only trained on simple domain geometries as presented in appendix C. Still, as can be seen in Figure 8, the network is capable of generalizing to far more complicated domain geometries (e.g. shark, car). Figure 8c shows that it can generalize to multiple objects in the scene, although the training set contained at most one object per scene. And Figure 8d shows that we can alter the outer boundary conditions as well. For real-time simulations, please have a look at our source code and the supplementary video. ",
+        "bbox": [
+            174,
+            728,
+            825,
+            813
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E QUANTITATIVE ANALYSIS: THE BENCHMARK PROBLEM ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            834,
+            673,
+            852
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 9 shows the domain $\\Omega$ and $v _ { d }$ on a $1 0 0 \\times 1 0 0$ grid which was used as the benchmark problem for quantitative analysis. The flow speed for the inlet and outlet was set to 0.5. The timestep of the integrator was set to $d t = 4$ and the viscosity and fluid density were set to $\\mu = 0 . 1$ and $\\rho = 4$ respectively. ",
+        "bbox": [
+            173,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/0679b34b9e40dd6fbcd896e5dfe9d2350e866f3fa97de7241da416b4cf20acb7.jpg",
+        "image_caption": [
+            "Figure 7: The left column shows $\\Omega$ (in white) / $\\partial \\Omega$ (in black) and the right column shows $\\vec { v _ { d } }$ for three examples of training domains. (Colors indicate the direction and magnitude of $\\vec { v _ { d } }$ as depicted in Figure 9a) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            112,
+            736,
+            376
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/96b4681cd4da05c85f6888b7d4f74625dfc620d8aa2ce10458c046f72e55cfd8.jpg",
+        "image_caption": [
+            "Figure 8: Our models generalize to various domain geometries, although being trained only on simple shapes (see Figure 7) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            444,
+            790,
+            650
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F QUALITATIVE COMPARISON OF $\\vec { a }$ -NET AND $\\vec { v }$ -NET ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            713,
+            625,
+            729
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We give a qualitative example to show the benefits of using a vector potential. Figure 10 demonstrates that the $\\vec { a }$ -Net finds plausible solutions for a folded pipe domain while the $\\vec { v }$ -Net looses most of the flow in the center of the domain. This is in good accordance with quantitative results shown in section 1. The folded pipe domain is particularly difficult to learn as the flow field contains long range dependencies to the inlet and outlet (as shown in the bottom row in Figure 7). ",
+        "bbox": [
+            174,
+            746,
+            825,
+            815
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "G TRAINING WITHOUT RESETTING ENVIRONMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            837,
+            619,
+            852
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We performed an ablation study to investigate what happens if we do not reset old environments from time to time and, thus, do not continuously present the fluid model with cold starts during training. Figure 11 shows that in this case, large error spikes appear in the validation curve. These error spikes appear since the model has troubles to perform a cold start as can be seen in Figure 11b: compared to a properly trained model (see Figure 4) the model takes longer to perform a cold start (ca 100 steps) and converges to a solution with high $L _ { p }$ - and $L _ { d } .$ - losses. By resetting the environments from time to time during training, we can prevent these error spikes as shown in Figure 11c. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ef32d47da39bc6f2709e48b8263109e11b93a309f24cdd7e9700f02552db9ad.jpg",
+        "image_caption": [
+            "Figure 9: a) shows legend for $\\scriptstyle { \\vec { v _ { d } } }$ ; b) shows $\\Omega$ (in white) $/ \\partial \\Omega$ (in black) for the benchmark problem; c) shows $\\vec { v _ { d } }$ for the benchmark problem. (Colors indicate the direction of $\\vec { v _ { d } }$ as depicted in a) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            302,
+            112,
+            691,
+            242
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c6c35a94812aee60c202ac85d9e3bb29901144c51d0e016529668a2acd428f16.jpg",
+        "image_caption": [
+            "Figure 10: Qualitative comparison of $\\vec { a }$ -Net and $\\vec { v }$ -Net in a folded pipe domain "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            309,
+            813,
+            411
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            463,
+            825,
+            506
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/e9613f5f266dea5d70e2be191186fc22a58c75552972d2b5b6f43b06f8bbc705.jpg",
+        "image_caption": [
+            "Figure 11: a) ablation study without resetting environments: validation curve shows large error spikes during training; b) error spike: the fluid model takes longer to perform a cold start and converges to a solution with high losses; c) original training with resetting environments: validation curve is stable "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            532,
+            818,
+            669
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SklcyJBtvB/SklcyJBtvB.md

@@ -0,0 +1,406 @@
+# OFF-POLICY BANDITS WITH DEFICIENT SUPPORT
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Off-policy training of contextual-bandit policies is attractive in online systems (e.g. search, recommendation, ad placement), since it enables the reuse of large amounts of log data. State-of-the-art methods for off-policy learning, however, are based on inverse propensity score (IPS) weighting, which requires that the logging policy chooses all actions with non-zero probability for any context (i.e., full support). In real-world systems, this condition is often violated, and we show that existing off-policy learning methods based on IPS weighting can fail catastrophically. We therefore develop new off-policy contextual-bandit methods that can controllably and robustly learn even when the logging policy has deficient support. To this effect, we explore three approaches that provide various guarantees for safe learning despite the inherent limitations of support deficient data: restricting the action space, reward extrapolation, and restricting the policy space. We analyze the statistical and computational properties of these three approaches, and empirically evaluate their effectiveness in a series of experiments. We find that controlling the policy space is both computationally efficient and that it robustly leads to accurate policies.
+
+# 1 INTRODUCTION
+
+Many interactive systems (e.g., voice assistants, recommender systems, ad placement) can be modeled as contextual bandit problems (Langford & Zhang, 2008). In particular, each user request provides a context (e.g., user profile, query) for which the system selects an action (e.g., recommended product, presented ad) and receives a reward (e.g., purchase, click). Such contextual-bandit data is logged in large quantities as a by-product of normal system operation (Li et al., 2011; 2015; Joachims et al., 2017), making it an attractive and low-cost source of training data. With terabytes of such log data readily available in many online systems, a range of algorithms have been proposed for batch learning from such logged contextual-bandit feedback (Strehl et al., 2011; Dud´ık et al., 2011; Swaminathan & Joachims, 2015a; Thomas & Brunskill, 2016; Farajtabar et al., 2018; Su et al., 2019; London & Sandler, 2019). However, as we will argue below, these algorithms require an assumption about the log data that makes them unsuitable for many real-world applications.
+
+This assumption is typically referred to as the positivity or support assumption, and it is required by the Empirical Risk Minimization (ERM) objective that these algorithms optimize. Specifically, unlike in online learning for contextual bandits (Williams, 1992; Agarwal et al., 2014), batch learning from bandit feedback (BLBF) operates in the off-policy setting. During off-policy learning, the algorithm has to address the counterfactual question of how much reward each policy in the policy space would have received, if it had been used instead of the logging policy. To this effect, virtually all state-of-the-art off-policy learning methods for contextual-bandit problems rely on counterfactual estimators (Bottou et al., 2013; Dud´ık et al., 2011; Swaminathan & Joachims, 2015a; Thomas & Brunskill, 2016; Farajtabar et al., 2018; Su et al., 2019) that employ inverse propensity score (IPS) weighting to get an unbiased ERM objective. Unlike regression-based direct-modeling (DM) approaches that are often hampered by bias from model-misspecification, IPS allows a controllable bias-variance trade-off through clipping and other variance-regularization techniques (Strehl et al., 2011; Swaminathan & Joachims, 2015a; London & Sandler, 2019).
+
+Unfortunately, IPS and its variance-control mechanisms break down when the logging policy does not have full support – meaning that some actions have zero probability of being selected under the logging policy. In this case IPS can be highly biased. Full support is an unreasonable assumption in many real-world systems, especially when the action space is large and many actions have poor rewards. For example, in a recommender system with a large catalog (e.g. movies, music), it may be that less than $10 \%$ of the actions have support under the logging policy. We will show that existing learning algorithms can fail catastrophically on such support deficient data.
+
+In this paper, we develop new off-policy contextual-bandit algorithms that are specifically designed to deal with support deficient log data. Since support deficiency translates into blind spots where we do not have any knowledge about the rewards, accounting for these blind spots as part of learning is crucial for robust learning. We approach this problem from three perspectives. First, we explore restricting the action space to those actions that have support under the logging policy. Second, we explore imputation methods that extrapolate estimated rewards to those blind spots. And, third, we restrict the policy space to only those policies that have limited exposure to the blind spots. To make the latter approach computationally tractable, we define a new measure of Support Divergence between policies, show how it can be estimated efficiently without closed-form knowledge of the logging policy, and how it can be used as a constraint on the policy space. We analyze the statistical and computational properties of all three approaches and perform an extensive empirical evaluation. We find that restricting the policy space is particularly effective, since it is computationally efficient, empirically effective at learning good policies, and convenient to use in practice.
+
+# 2 RELATED WORK
+
+Most prior works on BLBF can be classified into two different approaches. The first – called Direct Model (DM) – is based on a reduction to supervised learning, where a regression estimate is trained to predict rewards (Beygelzimer & Langford, 2009). To derive a policy, the action with the highest predicted reward is chosen. A drawback of this simple approach is the bias that results from misspecification of the regression model. Since regression models are often substantially misspecified for real-world data, the DM approach often does not work well empirically.
+
+The second approach is based on policy learning via ERM with a counterfactual risk estimator. Inverse propensity score (IPS) weighting is one of the most popular estimators to be used as empirical risk. However, policy learning algorithms based on IPS and related estimators (Strehl et al., 2011; Swaminathan & Joachims, 2015a;b; Thomas & Brunskill, 2016; London & Sandler, 2019) require the assumption that the logging policy has full support for every policy in the policy space. One exception is the work of Liu et al. (2019). They relax the assumption to the existence of an optimal policy such that the logging policy covers the support of this optimal policy. However, this is an untestable assumption that does not provide guarantees for real-world applications.
+
+Our work proposes three approaches to addressing off-policy learning with support deficiency. First, our conservative extrapolation method is related to the method proposed by Liu et al. (2019). They focus on the correction of the state distribution by defining an augmented MDP, and pessimistic imputation is used to get an estimate for policy-gradient learning. Second, our method of restricting the policy space uses a surrogate for the support divergence of two policies that was previously used as control variate in the SNIPS estimator (Swaminathan & Joachims, 2015b). It also appeared in the Lagrangian formulation of the BanditNet objective (Joachims et al., 2018) and in the gradient update in REINFORCE algorithm (Williams, 1992). This connection gives interesting new insight that the baselines used in policy-gradient algorithms not only help to reduce variance in gradients (Greensmith et al., 2004), but that they also connect to the problem of support deficiency in the off-policy setting.
+
+# 3 OFF-POLICY LEARNING WITH DEFICIENT SUPPORT
+
+We start by formally defining the problem of learning a contextual-bandit policy in the BLBF setting. Input to the policy are contexts $x \in \mathcal { X }$ drawn i.i.d from a fixed but unknown distribution $P ( \mathcal X )$ . Given context $x$ , the system executes a possibly stochastic policy $\pi ( \mathcal { V } | x )$ that selects an action $y \in \mathcal { V }$ . For this context and action pair, the system observes a reward $r \in [ r _ { m i n } , r _ { m a x } ]$ from $P ( r | x , y )$ . Given a space of policies $\Pi$ , the reward of any policy $\pi \in \Pi$ is defined as
+
+$$
+R ( \pi ) = \underset { x } { \mathbb { E } } \underset { y \sim \pi ( y \mid x ) } { \mathbb { E } } \underset { r \sim P ( r \mid x , y ) } { \mathbb { E } } [ r ] .
+$$
+
+In the BLBF setting, the learning algorithm is given a dataset
+
+$$
+\mathcal { D } : = \{ x _ { i } , y _ { i } , r _ { i } , \pi _ { 0 } ( y _ { i } | x _ { i } ) \} _ { i = 1 } ^ { n }
+$$
+
+of past system interactions which consists of context-action-reward-propensity tuples. The propensity $\pi _ { 0 } ( y _ { i } | x _ { i } )$ is the probability of selecting action $y _ { i }$ for context $x _ { i }$ under the policy $\pi _ { 0 }$ that was used to log the data. We call $\pi _ { 0 }$ the logging policy, and we will discuss desired conditions on the stochasticity of $\pi _ { 0 }$ in the following. The goal of off-policy learning is to exploit the information in the logged data $\mathcal { D }$ to find a policy ${ \hat { \pi } } \in \Pi$ that has high reward $R ( { \hat { \pi } } )$ .
+
+Analogous to the ERM principle in supervised learning, off-policy learning algorithms typically optimize a counterfactual estimate $\hat { R } ( \pi )$ of $R ( \pi )$ as the training objective (Li et al., 2011; 2015; Bottou et al., 2013; Swaminathan & Joachims, 2015a).
+
+$$
+\hat { \pi } = \underset { \pi \in \Pi } { \arg \operatorname* { m a x } } [ \hat { R } ( \pi ) ]
+$$
+
+For conciseness, we ignore additional regularization terms in the objective (Swaminathan & Joachims, 2015a), since they are irrelevant to the main point of this paper. As counterfactual estimator $\hat { R } ( \pi )$ , most algorithms rely on some form of IPS weighting (Strehl et al., 2011; Dud´ık et al., 2011; Swaminathan & Joachims, 2015a;b; Wang et al., 2017; Su et al., 2019) to correct the distribution mismatch between the logging policy $\pi _ { 0 }$ and each target policy $\pi \in \Pi$ .
+
+$$
+\hat { R } _ { I P S } ( \pi ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \pi ( y _ { i } | x _ { i } ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } r _ { i } .
+$$
+
+A crucial condition for the effectiveness of the IPS estimator (and similar estimators) is that the logging policy $\pi _ { 0 }$ assigns non-zero probability to all actions that have non-zero probability under the target policy $\pi$ we aim to evaluate. This condition is known as positivity or full support, and it is defined as follows.
+
+Definition 1 (Full support). The logging policy $\pi _ { 0 }$ is said to have full support for $\pi$ when $\pi _ { 0 } ( y | x ) >$ 0 for all actions $y \in \mathcal { V }$ and contexts $x \in \mathcal { X }$ for which $\pi ( y | x ) > 0$ .
+
+It is known that the IPS estimator is unbiased, $\mathbb { E } _ { \mathcal { D } } [ \hat { R } _ { I P S } ( \pi ) ] = R ( \pi )$ , if the logging policy $\pi _ { 0 }$ has full support for $\pi$ (Li et al., 2011). To ensure unbiased ERM, algorithms that use the IPS estimator require that the logging policy $\pi _ { 0 }$ has full support for all policies $\pi \in \Pi$ in the policy space. For sufficiently rich policy spaces, like deep-networks $f _ { w } ( x , y )$ with softmax outputs of the form
+
+$$
+\pi _ { w } ( y | x ) = \frac { e x p ( f _ { w } ( x , y ) ) } { \sum _ { y ^ { \prime } \in \mathcal { V } } e x p ( f _ { w } ( x , y ^ { \prime } ) ) } ,
+$$
+
+this means that the logging policy $\pi _ { 0 }$ needs to assign non-zero probability to every action $y$ in every context $x$ . This is a strong condition that is not feasible in many real-world systems, especially if the action space is large and many actions have poor reward.
+
+If the support requirement is violated, ERM learning can fail catastrophically. We will show below that the underlying reason is bias, not excessive variance that could be remedied through clipping or variance regularization (Strehl et al., 2011; Swaminathan $\&$ Joachims, 2015a). To quantify how support deficient a logging policy is, we denote the set of unsupported actions for context $x$ under $\pi _ { 0 }$ as
+
+$$
+\mathcal { U } ( x , \pi _ { 0 } ) : = \{ y \in y | \pi _ { 0 } ( y | x ) = 0 \} .
+$$
+
+The bias of the IPS estimator is then characterized by the expected reward on the unsupported actions.
+
+Proposition 1. Given contexts $x \sim P ( \mathcal { X } )$ and logging policy $\pi _ { 0 } ( \mathcal { V } | x )$ , the bias of $\hat { R } _ { I P S }$ for target policy $\pi ( \mathcal { V } | x )$ is equal to the expected reward on the unsupported action sets, i.e., $b i a s ( \pi | \pi _ { 0 } ) =$ $\begin{array} { r } { \mathbb { E } _ { x } [ - \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \delta ( x , y ) ] } \end{array}$ .
+
+The proof is in Appendix A.1. From Proposition 1, it is clear that support deficient log data can drastically mislead ERM learning. To quantify the effect of support deficiency on ERM, we define the support divergence between a logging policy $\pi _ { 0 }$ and a target policy $\pi$ as follows.
+
+Definition 2 (Support Divergence). For contexts $x \sim P ( \mathcal { X } )$ and any corresponding pair of target policy $\pi$ and logging policy $\pi _ { 0 }$ , the Support Divergence is defined as
+
+$$
+\mathcal { D } _ { \mathcal { X } } \big ( \pi \big | \pi _ { 0 } \big ) : = \underset { x \sim P ( \mathcal { X } ) } { \mathbb { E } } \left[ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \right] .
+$$
+
+With this definition in hand, we can quantify the effect of support deficiency on ERM learning for a policy space $\Pi$ under logging policy $\pi _ { 0 }$ .
+
+Theorem 1. For any given hypothesis space $\Pi$ with logging policy $\pi _ { 0 } ~ \in ~ \Pi$ , there exists a reward distribution $\mathcal { P } _ { r }$ with support in $[ r _ { m i n } , r _ { m a x } ]$ such that in the limit of infinite training data, ERM using IPS over the logged data $\mathcal D \sim \dot { P } ( \mathcal X ) \times \pi _ { 0 } ( \cdot | \mathcal X ) \times \mathcal P _ { r }$ can select a policy $\begin{array} { r } { \hat { \pi } \in \arg \operatorname* { m a x } _ { \pi \in \Pi } \mathbb { E } _ { \mathcal { D } } [ \hat { R } _ { I P S } ( \pi ) ] } \end{array}$ that is at least $\begin{array} { r l } {  { ( r _ { m a x } - r _ { m i n } ) \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) } \quad } & { { } } \end{array}$ suboptimal.
+
+The proof is in Appendix A.2. To illustrate the theorem, consider a problem with rewards $r \in$ $[ - 1 , 0 ]$ . Furthermore, consider a policy space $\Pi$ that contains a good policy $\pi _ { g }$ with $R ( \pi _ { g } ) = - 0 . 1$ and a bad policy $\pi _ { b }$ with $R ( \pi _ { b } ) = - 0 . 7 .$ . If policy $\pi _ { b }$ has support divergence $\mathcal { D } _ { \mathcal { X } } ( \pi _ { b } \vert \pi _ { 0 } ) = 0 . 6$ or larger, then ERM may return the bad $\pi _ { b }$ instead of $\pi _ { g }$ even with infinite amounts of training data.
+
+Note that it is sufficient to merely have one policy in $\Pi$ that has large support deficiency to achieve this suboptimality. It is therefore crucial to control the support divergence $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ uniformly over all $\pi \in \Pi$ , or to account for the suboptimality it can induce. To this effect, we explore three approaches in the following.
+
+# 3.1 SAFE LEARNING BY RESTRICTING THE ACTION SPACE
+
+The first and arguably most direct approach to reducing $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ is to disallow any action that has zero support under the logging policy. For the remaining action set, the logging policy has full support by definition. This restriction of the action set can be achieved by transforming each policy $\pi \in \Pi$ into a new policy that sets the probability of the unsupported actions to zero.
+
+$$
+\pi ( y | x ) \longrightarrow \bar { \pi } ( y | x ) : = \frac { \pi ( y | x ) \mathbb { 1 } _ { \{ y \notin \mathcal { U } ( x , \pi _ { 0 } ) \} } } { 1 - \sum _ { y ^ { \prime } \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y ^ { \prime } | x ) }
+$$
+
+This results in a new policy space $\bar { \Pi }$ . All $\bar { \pi } \in \bar { \Pi }$ have support divergence of zero $\mathcal { D } _ { \mathcal { X } } ( \bar { \pi } | \pi _ { 0 } ) = 0$ and ERM via IPS is guaranteed to be unbiased.
+
+While this transformation of the policy space from $\Pi$ to $\bar { \Pi }$ is conceptually straightforward, it has two potential drawbacks. First, restricting the action space without any exceptions may overly constrain the policies in $\bar { \Pi }$ . In particular, if the optimal action $y ^ { * }$ for a specific context $x$ does not have support under the logging policy, no $\bar { \pi } \in \dot { \bar { \Pi } }$ can ever choose $y ^ { * }$ even if there are many observations of similar $y$ ’s on similar context $x ^ { \prime }$ . The second drawback is computational. For every context $x$ during training and testing, the system needs to evaluate the logging policy $\pi _ { 0 } ( y | x )$ to compute the transformation from $\pi$ to $\bar { \pi }$ . This can be prohibitively expensive especially at test time, where – after multiple rounds of off-policy learning with data from previously learned policies – we would need to evaluate the whole sequence of previous logging policies to execute the learned policy.
+
+# 3.2 SAFE LEARNING THROUGH REWARD EXTRAPOLATION
+
+As illustrated above, support deficiency is a problem of blind spots where we lack information about the rewards of some actions in some contexts. Instead of disallowing the unsupported actions like in the previous section, an alternative is to extrapolate the observed rewards to fill in the blind spots. To this effect, we propose the following augmented IPS estimator that imputes an extrapolated reward $\hat { \delta } ( x , y )$ for each unsupported action $y \in \mathcal { U } ( x , \pi _ { 0 } )$ .
+
+$$
+\hat { R } _ { I P S } ^ { \delta } ( \pi ) = \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \left[ \frac { \pi ( y _ { i } | x _ { i } ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } r _ { i } + \sum _ { y \in \mathcal { U } ( x _ { i } , \pi _ { 0 } ) } \pi ( y | x _ { i } ) \hat { \delta } ( x _ { i } , y ) \right]
+$$
+
+In the following proposition, we characterize the bias of the augmented IPS estimator for any given reward extrapolation $\hat { \delta } ( x , y )$ . We denote the mean of the reward $r$ for context $x$ and action $y$ with $\delta ( x , y ) = \mathbb { E } _ { r \sim P ( r | x , y ) } [ r ]$ . Furthermore, $\Delta ( x , y ) : = \hat { \delta } ( x , y ) - \delta ( x , y )$ denotes the error of the reward extrapolation for each $x$ and $y$ .
+
+Proposition 2. Given contexts $x _ { 1 } , x _ { 2 } , \ldots , x _ { n }$ drawn i.i.d from the unknown distribution $P ( \mathcal X )$ , for action $y _ { i }$ drawn independently from logging policy $\pi _ { 0 }$ with probability $\pi _ { 0 } ( \mathcal { V } | x _ { i } )$ , the bias of the empirical risk defined in Equation (7) is $\begin{array} { r } { \mathbb E _ { x } [ \sum _ { y \in \mathcal U _ { x } ^ { \pi _ { 0 } } } \pi ( y | x ) \Delta ( x , y ) ] } \end{array}$ .
+
+In this way we can learn in the original action and policy space, but mitigate the effect of the support deficiency by explicitly incorporating the extrapolated reward $\hat { \delta } ( x , y )$ . We explore two choices for $\hat { \delta } ( x , y )$ in the following, which provide different types of guarantees.
+
+Conservative Extrapolation. To minimize the user impact of randomization in the logging policy, it is generally desirable to put zero probability on actions the are very likely to have low (or even catastrophic reward). This means that precisely those bad actions are likely to not be supported in the logging policy. A key danger of blind spots regarding those actions is that naive IPS training will inadvertently learn
+
+# Algorithm 1: Data Augmentation
+
+input: original logged dataset $\mathcal { D }$ , replaycount $k$ ,   
+reward estimate $\hat { \delta } ( x , y )$ ; output: $\mathcal { D } ^ { \prime }$ ;   
+initialization: $\mathcal { D } ^ { \prime } = \varnothing$ ;   
+for $j = 1 , \dots , k$ do for $i = 1 , \ldots , n$ do Define $U _ { x _ { i } }$ to be the uniform distribution over $\mathcal { U } ( x _ { i } , \pi _ { 0 } )$ ; Draw $y \sim U _ { x _ { i } }$ ; $\begin{array} { r } { \mathcal { D } ^ { \prime } = \mathcal { D } ^ { \prime } \bigcup \{ x _ { i } , y , \hat { \delta } ( x _ { i } , y ) , \frac { 1 } { | \mathcal { U } ( x _ { i } , \pi _ { 0 } ) | } \} ; } \end{array}$ end   
+end
+
+a policy that selects those actions. This can be avoided by being maximally conservative about unsupported actions and imputing the lowest possible reward $\forall x , y \in \mathcal { U } ( x , \pi _ { 0 } ) : \hat { \delta } ( x , y ) = r _ { m i n }$ . Intuitively, by imposing the worst possible reward for the unsupported actions, the learning algorithm will aim to avoid these low-reward areas. However, unlike for the $\bar { \pi }$ policies resulting from the restricted action space, the learned policy is not strictly prohibited from choosing unsupported actions – it is merely made aware of the maximum loss that the action may incur. Note that for problems where $r _ { m i n } = 0$ , the naive IPS estimator is identical to conservative extrapolation since the second term in Equation (7) is zero.
+
+Regression Extrapolation. Instead of extrapolating with the worst-case reward, we may have additional prior knowledge in the form of a model-based estimate that reduces the bias. In particular, we explore using a regression estimate $\begin{array} { r } { \hat { \delta } = \arg \operatorname* { m i n } _ { \hat { \delta } ^ { \theta } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } ( \hat { \delta } ^ { \theta } ( x _ { i } , y _ { i } ) - r _ { i } ) ^ { 2 } } \end{array}$ that extrapolates from the observed data $\mathcal { D }$ . Typically, comes from a parameterized class of regression functions. Other regression objectives could also be used, such as weighted linear regression that itself uses importance sampling as weights (Farajtabar et al., 2018). But, fundamentally, all regression approaches assume that the regression model is not misspecified and that it can thus extrapolate well. Note that the IPS part of Equation (7) can be changed to any estimators (with action set restricted on $\boldsymbol { \mathcal { U } } ( \boldsymbol { x } , \pi _ { 0 } ) ^ { c }$ for all $x$ ), and it turns out that doubly robust (Dud´ık et al., 2011) and CAB (Su et al., 2019) are special extensions of regression extrapolation that substitute the IPS part with their corresponding estimator.
+
+Efficient Approximation. Evaluating the augmented IPS estimator from Equation (7) can be computationally expensive if the number of unsupported actions $\boldsymbol { \mathcal { U } } ( \boldsymbol { x } , \pi _ { 0 } )$ is large. To overcome this problem, we propose to use sampling to estimate the expected reward on the unsupported action, which can be thought of as augmenting the dataset $\mathcal { D }$ with additional observations where the logging policy has zero support. In particular, we propose the data-augmentation procedure detailed in Algorithm 1. With the additional bandit data $\mathcal { D } ^ { \prime } = \{ x _ { j } ^ { \prime } , y _ { j } ^ { \prime } , \hat { \delta } ( x _ { j } ^ { \prime } , y _ { j } ^ { \prime } ) , p _ { j } ^ { \prime } \} _ { j = 1 } ^ { m }$ from Algorithm 1, the new objective is
+
+$$
+\underset { \pi \in \Pi } { \arg \operatorname* { m i n } } \left\{ \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \pi ( y _ { i } | x _ { i } ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } r _ { i } + \frac { 1 } { m } \sum _ { j = 1 } ^ { m } \frac { \pi ( y _ { j } ^ { \prime } | x _ { j } ^ { \prime } ) } { p _ { j } ^ { \prime } } \hat { \delta } ( x _ { j } ^ { \prime } , y _ { j } ^ { \prime } ) \right\} .
+$$
+
+In Appendix A.5, we show that the empirical risk in Equation (8) has the same expectation (over randomness in $\mathcal { D }$ and $\mathcal { D } ^ { \prime }$ ) as $\hat { R } _ { I P S } ^ { \delta } ( \mathcal { D } )$ and can thus serve as an approximation for Equation (7).
+
+# 3.3 SAFE LEARNING BY RESTRICTING THE POLICY SPACE
+
+As motivated by Theorem 1, the risk of learning from support deficient data scales with the maximum support divergence $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ among the policies in the policy space $\Pi$ . Therefore, our third approach restricts the policy space to the subset $\Pi ^ { \kappa } \subset \Pi$ that contains the policies $\pi \in \Pi$ with an acceptably low support divergence $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } ) \le \kappa$ .
+
+$$
+\Pi ^ { \kappa } = \{ \pi | \pi \in \Pi \wedge { \mathscr { D } } \chi ( \pi | \pi _ { 0 } ) \leq \kappa \}
+$$
+
+The parameter $\kappa$ has an intuitive meaning. It specifies the maximum probability mass that a learned policy can place on unsupported actions. By limiting this to $\kappa$ , we limit the maximum bias of the ERM procedure according to Proposition 2 while not explicitly torquing the rewards like in conservative reward imputation.
+
+A key challenge, however, is implementing this restriction of the hypothesis space, such that the ERM learner $\hat { \pi } = \arg \operatorname* { m a x } _ { \pi \in \Pi ^ { \kappa } } [ \hat { R } _ { I P S } ( \pi ) ]$ only considers the subset $\Pi ^ { \kappa } \subset \Pi$ . In particular, we do not have access to the context distribution $P ( \mathcal X )$ for calculating $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ , nor would it be possible to enumerate all $\pi \in \Pi$ to check the condition $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } ) ~ \le ~ \kappa$ , which itself requires a possibly infeasible iteration over all actions. The following theorem (with proof in Appendix A.3) gives us an efficient way of estimating and controlling $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ without explicit knowledge of $P ( \mathcal X )$ or access to the logging policy $\pi _ { 0 }$ beyond the logged propensities.
+
+Theorem 2. For contexts $x _ { i }$ drawn i.i.d from $P ( \mathcal X )$ , action $y _ { i }$ drawn from logging policy $\pi _ { 0 }$ , we define SD(π|π0) = 1n Pni=1 π(yi|xi)π0(yi|xi) . For any policy $\pi$ it holds that
+
+$$
+\begin{array} { r } { \underset { x \sim P ( \mathcal { X } ) } { \mathbb { E } } \underset { y \sim \pi _ { 0 } ( \cdot | x ) } { \mathbb { E } } [ S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) ] + \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) = 1 } \end{array}
+$$
+
+Using this theorem, the following proposition (proof in Appendix A.4, empirically verified in Appendix B) gives us an efficient way of implementing the constraint $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } ) \le \kappa$ via $1 - S _ { D } ( \pi | \pi _ { 0 } )$ .
+
+Proposition 3. For any given $\kappa \in ( 0 , 1 )$ , $0 < \epsilon < \kappa / 2$ , let $p _ { m i n }$ denote the minimum propensity under supported set $p _ { m i n } ~ = ~ m a x _ { x , y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi _ { 0 } ( y | x )$ , then with probability larger than $1 - 2 \exp ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } )$ , the constraint $1 - \kappa { + } \epsilon \le S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) \le 1 { - } \epsilon$ will ensure $0 \leq \mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } ) \leq \kappa$ .
+
+We can thus use $1 - S _ { D } ( \pi | \pi _ { 0 } )$ as a surrogate for $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ in the training objective:
+
+$$
+\underset { \pi _ { w } \in \Pi } { \arg \operatorname* { m i n } } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \pi _ { w } ( y _ { i } | x _ { i } ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } r _ { i } . \mathrm { ~ s u b j e c t ~ t o ~ } 1 - \kappa + \epsilon \leq \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \pi _ { w } ( y _ { i } | x _ { i } ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } \leq 1 - \epsilon
+$$
+
+Using Lagrange multipliers, an equivalent dual form of Equation (11) is:
+
+$$
+\operatorname* { m a x } _ { u _ { 1 } , u _ { 2 } \geq 0 } \operatorname* { m i n } _ { \pi _ { w } \in \Pi } \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \pi _ { w } ( y _ { i } | x _ { i } ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } ( r _ { i } + u _ { 1 } - u _ { 2 } ) - u _ { 1 } ( 1 - \epsilon ) + u _ { 2 } ( 1 - \kappa + \epsilon )
+$$
+
+For each fixed $( u _ { 1 } , u _ { 2 } )$ pair, the inner minimization objective is ERM with IPS under a shift of the reward. Instead of maximizing over $( u _ { 1 } , u _ { 2 } )$ in the outer objective, we treat $( u _ { 1 } - u _ { 2 } )$ as a hyperparameter that we select on a validation set. We explore various estimators for this modelselection problem in Section 4.
+
+Note that, among the methods we proposed for dealing with support deficiency, this approach is the most efficient to implement, and it does not require access to the logging policy during training or testing. Furthermore, the form of the inner objective coincides with that of BanditNet (Joachims et al., 2018), which is known to work well for deep network training by controlling propensity overfitting (Swaminathan & Joachims, 2015a).
+
+# 4 EMPIRICAL EVALUATION
+
+We empirically evaluate the effectiveness and robustness of the three proposed approaches: restricting the action space, conservative and regression extrapolation, as well as restricting the policy space. The semi-synthetic experiments are based on two real-world datasets: one is the popular image classification dataset CIFAR10 (Krizhevsky et al.) and the other is the credit-card fraud dataset of Dal Pozzolo et al. (2015). We use the naive IPS estimator and the regression-based Direct Method (DM) as baselines.
+
+The experiments are set up as follows. We first create a train-validation-test split for both datasets. The training set is used to generate bandit datasets for learning, the validation set is used to generate bandit datasets for model selection, and the full-information test set serves as ground truth for evaluating the learned policies. To simulate bandit feedback for the CIFAR10 dataset, our experiment setup follows traditional supervised bandit conversion for multi-class classification datasets (Beygelzimer & Langford, 2009). To not only have bandit data with binary multi-class rewards, we choose a different methodology for the credit-card dataset by designating some features as corresponding to actions and rewards. More details are given in Appendix B.
+
+To get logging policies for generating bandit feedback, we start by training a softmax-policy as in Equation (4) on a subset of the full-information data. We then introduce a temperature parameter $\tau$ into the learned policy via $\tau f _ { w } ( x , y )$ to be able to control its stochasticity and support deficiency. In particular, we enforce zero support for some actions by clipping the propensities to 0 if they are below a threshold of $\epsilon = 0 . 0 1$ . The larger $\tau$ , the higher the support deficiency. Note that making the threshold at $\epsilon = 0 . 0 1$ allows us to control support while the variance of IPS stays bounded. This allows us to study support deficiency without having to worry about variance control.
+
+For both logging and target policies, we train softmax policies where $f _ { w } ( x , y )$ is a neural network. We use the ResNet20 architecture (He et al., 2016) for CIFAR10, and a fully-connected 2-layer network for the credit-card dataset.
+
+![](images/28a0537b9d42908064e6c5fb86cdcb47b4f7d8597ca2d9309b1cb944a9c7dace.jpg)  
+Figure 1: Learning results with varying support deficiency in the logging policy.
+
+How do the methods perform at different level of support deficiency? Results are shown in Figure 1. First, as expected, learning using naive IPS degrades on both datasets as we make the logging policy more peaked and the number of unsupported actions increases. Note that naive IPS coincides with Conservative Extrapolation, since both datasets are scaled to have a minimum reward of zero. In the rightmost column, however, we translated the rewards to $[ - 1 , 0 ]$ . This has a strong detrimental effect on naive IPS, as it is now overly optimistic about unsupported actions. Second, the approach of dealing with support deficiency by restricting the action space also performs poorly. The second row of plot sheds some light on this, as it shows the support divergence $\mathcal { D } _ { \mathcal { X } } ( \pi \vert \pi _ { 0 } )$ of the learned policy. It is zero for Action Restriction as expected, which means that bias is not the problem. Instead, as the number of unsupported actions increases, the best actions are more likely to be pruned and unavailable in the restricted policy space $\bar { \Pi }$ . Third, Regression Extrapolation performs better than Conservative Extrapolation on both datasets. In both cases, the DM model is quite good which also benefits Regression Extrapolation. However, on the credit-card dataset the regression seems better at ranking than at predicting the true reward, which explains why DM performs better than Regression Extrapolation. Fourth, the method that performs well most consistently is Policy Restriction. Unlike all the other IPS-based methods, it performs well even under the translated rewards in the third column of Figure 1. This is because the objective of Policy Restriction coincides with that of BanditNet (Joachims et al., 2018), which is known to remedy propensity overfitting due to the lack of equivariance of the IPS estimator (Swaminathan & Joachims, 2015b).
+
+How does the learning performance change with more training data? Results are shown in Figure 2. As the number of bandit examples increases, Policy Restriction, Regression Extrapolation and DM dominate over most of the range especially when the percentage of unsupported actions is large. Among the other methods, Action Restriction can take the least advantage of more data. This is plausible, since its maximum performance is limited by the available actions. For similar reasons, Conservative Extrapolation (and equivalently IPS) also flattens out, since it also tightly restricts the action space by imputing the minimum reward.
+
+![](images/aa8a5d1278cce3164dc98804179215126bb0ed224e646e59e7747093d8691b15.jpg)  
+Figure 2: Learning results with varying amounts of bandit data on CIFAR10 and credit-card dataset.
+
+<table><tr><td rowspan=1 colspan=1>%Unsupp.</td><td rowspan=1 colspan=1>Oracle</td><td rowspan=1 colspan=1>Regr.Extrap.</td><td rowspan=1 colspan=1>DM</td><td rowspan=1 colspan=1>Cons.Extrap.</td><td rowspan=1 colspan=1>SNIPS</td></tr><tr><td rowspan=1 colspan=1>45</td><td rowspan=1 colspan=1>0.878</td><td rowspan=1 colspan=1>0.878</td><td rowspan=1 colspan=1>0.878</td><td rowspan=1 colspan=1>0.878</td><td rowspan=1 colspan=1>0.876</td></tr><tr><td rowspan=1 colspan=1>60</td><td rowspan=1 colspan=1>0.871</td><td rowspan=1 colspan=1>0.871</td><td rowspan=1 colspan=1>0.871</td><td rowspan=1 colspan=1>0.871</td><td rowspan=1 colspan=1>0.871</td></tr><tr><td rowspan=1 colspan=1>70</td><td rowspan=1 colspan=1>0.858</td><td rowspan=1 colspan=1>0.858</td><td rowspan=1 colspan=1>0.856</td><td rowspan=1 colspan=1>0.858</td><td rowspan=1 colspan=1>0.858</td></tr><tr><td rowspan=1 colspan=1>77</td><td rowspan=1 colspan=1>0.856</td><td rowspan=1 colspan=1>0.854</td><td rowspan=1 colspan=1>0.854</td><td rowspan=1 colspan=1>0.856</td><td rowspan=1 colspan=1>0.856</td></tr><tr><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>0.855</td><td rowspan=1 colspan=1>0.855</td><td rowspan=1 colspan=1>0.855</td><td rowspan=1 colspan=1>0.838</td><td rowspan=1 colspan=1>0.849</td></tr></table>
+
+![](images/129795f238e4f9e260030195c39b917e0942e1c8abe6287722e9eee2e57b7f77.jpg)  
+Figure 3: Model selection performance on CIFAR10.
+
+How effective are the estimators for model selection? Most learning algorithms have hyperparameters, and we now evaluate how the estimators perform for this secondary learning problem. We specifically focus on the parameter $k : = u _ { 1 } - u _ { 2 }$ in Policy Restriction, since it controls how much the learned policies can step outside the region of support. The table on the left of Figure 3 shows the reward of the learned policy when performing model selection with the respective estimator. Oracle is the estimator that has access to the full-information validation set, and can thus be considered as a skyline. We also included the SNIPS estimator (Swaminathan & Joachims, 2015b), which imputes the average reward on the supported action for the unsupported actions (Gilotte et al., 2018). All estimators perform quite well for model selection on CIFAR, and the results are analogous for the credit-card data (see Appendix B.2). However, the plot to the right of Figure 3 reveals that SNIPS does not accurately reflect the shape of the Oracle curve. Both Regression Extrapolation and DM, however, are found to be sufficiently accurate for reliable model selection.
+
+# 5 DISCUSSION AND CONCLUSIONS
+
+We identified and analyzed how off-policy learning based on IPS weighting can suffer severely degraded learning performance when the logging policy is support deficient. To remedy this problem, we explored approaches that limit the impact of missing support through three different means: restricting the action space, reward extrapolation and restricting the policy space. We find that the most natural approach of restricting the action space is neither computationally efficient, nor does it learn accurate policies. Reward extrapolation through regression and restricting the policy space, however, both perform well and robustly even at high levels of support deficiency. Among those two methods, reward extrapolation has the potential drawback that we need to compute (and/or sample from) the complement of the logging policy, which can be computationally challenging. Furthermore, having to store all old logging policies is inconvenient in practice. This makes the approach of restricting the policy space particularly attractive, since it is computationally efficient and it does not require access to the logging policy beyond the logged propensity values.
+
+# REFERENCES
+
+Alekh Agarwal, Daniel Hsu, Satyen Kale, John Langford, Lihong Li, and Robert Schapire. Taming the monster: A fast and simple algorithm for contextual bandits. In International Conference on Machine Learning (ICML), 2014.
+
+Alina Beygelzimer and John Langford. The offset tree for learning with partial labels. In Proceedings of the 15th ACM SIGKDD international conference on Knowledge discovery and data mining, pp. 129–138. ACM, 2009.
+
+Leon Bottou, Jonas Peters, Joaquin Qui ´ nonero-Candela, Denis X Charles, D Max Chickering, Elon ˜ Portugaly, Dipankar Ray, Patrice Simard, and Ed Snelson. Counterfactual reasoning and learning systems: The example of computational advertising. The Journal of Machine Learning Research, 14(1):3207–3260, 2013.
+
+Andrea Dal Pozzolo, Olivier Caelen, Reid A Johnson, and Gianluca Bontempi. Calibrating probability with undersampling for unbalanced classification. In 2015 IEEE Symposium Series on Computational Intelligence, pp. 159–166. IEEE, 2015.
+
+Miroslav Dud´ık, John Langford, and Lihong Li. Doubly robust policy evaluation and learning. In International Conference on Machine Learning (ICML), 2011.
+
+Mehrdad Farajtabar, Yinlam Chow, and Mohammad Ghavamzadeh. More robust doubly robust off-policy evaluation. In International Conference on Machine Learning, pp. 1446–1455, 2018.
+
+Alexandre Gilotte, Clement Calauz ´ enes, Thomas Nedelec, Alexandre Abraham, and Simon Doll \` e.´ Offline a/b testing for recommender systems. In Proceedings of the Eleventh ACM International Conference on Web Search and Data Mining, pp. 198–206. ACM, 2018.
+
+Evan Greensmith, Peter L Bartlett, and Jonathan Baxter. Variance reduction techniques for gradient estimates in reinforcement learning. Journal of Machine Learning Research, 5(Nov):1471–1530, 2004.
+
+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, pp. 770–778, 2016.
+
+T. Joachims, A. Swaminathan, and T. Schnabel. Unbiased learning-to-rank with biased feedback. In ACM Conference on Web Search and Data Mining (WSDM), 2017.
+
+T. Joachims, A. Swaminathan, and M. de Rijke. Deep learning with logged bandit feedback. In International Conference on Learning Representations (ICLR), 2018.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/˜kriz/cifar.html.
+
+John Langford and Tong Zhang. The epoch-greedy algorithm for multi-armed bandits with side information. In Advances in neural information processing systems, pp. 817–824, 2008.
+
+Lihong Li, Wei Chu, John Langford, and Xuanhui Wang. Unbiased offline evaluation of contextualbandit-based news article recommendation algorithms. In Proceedings of the fourth ACM international conference on Web search and data mining, pp. 297–306. ACM, 2011.
+
+Lihong Li, Shunbao Chen, Jim Kleban, and Ankur Gupta. Counterfactual estimation and optimization of click metrics in search engines: A case study. In Proceedings of the 24th International Conference on World Wide Web, pp. 929–934. ACM, 2015.
+
+Yao Liu, Adith Swaminathan, Alekh Agarwal, and Emma Brunskill. Off-policy policy gradient with state distribution correction. arXiv preprint arXiv:1904.08473, 2019.
+
+Ben London and Ted Sandler. Bayesian counterfactual risk minimization. In International Conference on Machine Learning, pp. 4125–4133, 2019.
+
+Alex Strehl, John Langford, Lihong Li, and Sham M Kakade. Learning from logged implicit exploration data. In Advances in Neural Information Processing Systems (NIPS), 2011.
+
+Yi Su, Lequn Wang, Michele Santacatterina, and Thorsten Joachims. Cab: Continuous adaptive blending for policy evaluation and learning. In International Conference on Machine Learning, pp. 6005–6014, 2019.
+
+A. Swaminathan and T. Joachims. Batch learning from logged bandit feedback through counterfactual risk minimization. Journal of Machine Learning Research (JMLR), 16:1731–1755, Sep 2015a. Special Issue in Memory of Alexey Chervonenkis.
+
+A. Swaminathan and T. Joachims. The self-normalized estimator for counterfactual learning. In Neural Information Processing Systems (NIPS), 2015b.
+
+Philip Thomas and Emma Brunskill. Data-efficient off-policy policy evaluation for reinforcement learning. In International Conference on Machine Learning (ICML), 2016.
+
+Yu-Xiang Wang, Alekh Agarwal, and Miroslav Dudik. Optimal and adaptive off-policy evaluation in contextual bandits. In International Conference on Machine Learning (ICML), 2017.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+# A APPENDIX: PROOFS
+
+In this appendix, we provide proofs of the main theorems and propositions.
+
+# A.1 PROOF OF PROPOSITION 1
+
+Proposition 1. Given contexts $x \sim P ( \mathcal { X } )$ and logging policy $\pi _ { 0 } ( \mathcal { V } | x )$ , the bias of $\hat { R } _ { I P S }$ for target policy $\pi ( \mathcal { V } | x )$ is equal to the expected reward on the unsupported action sets, i.e., $b i a s ( \pi | \pi _ { 0 } ) =$ $\begin{array} { r } { \mathbb { E } _ { x } [ - \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \delta ( x , y ) ] } \end{array}$ .
+
+Proof. Recall $\delta ( x , y ) = \mathbb { E } _ { r } [ r ( x , y ) | x , y ]$ , and logged data $\mathcal { D } \sim \mathcal { P } _ { \mathcal { X } } \times \pi _ { 0 } ( \cdot | \mathcal { X } ) \times \mathcal { P } _ { r }$ .
+
+$$
+\begin{array} { l } { \displaystyle b i a s ( \pi | \pi _ { 0 } ) = \frac { \mathbb { E } [ \hat { R } _ { I P S } ( \pi ) ] - R ( \pi ) } { \mathcal { D } } } \\ { \displaystyle \quad = \frac { \mathbb { E } [ \sum _ { \scriptstyle x } } { y \in ( \mathcal { U } ( x , \pi _ { 0 } ) ) ^ { c } } \pi _ { 0 } ( y | x ) \frac { \pi ( y | x ) } { \pi _ { 0 } ( y | x ) } \delta ( x , y ) - \sum _ { y \in \mathcal { Y } } \pi ( y | x ) \delta ( x , y ) ] } \\ { \displaystyle \quad = \frac { \mathbb { E } [ - \sum _ { \scriptstyle x } } { x } - \pi ( y | x ) \delta ( x , y ) ] } \end{array}
+$$
+
+# A.2 PROOF OF THEOREM 1
+
+Theorem 1. For any given hypothesis space $\Pi$ with logging policy $\pi _ { 0 } ~ \in ~ \Pi$ , there exists a reward distribution $\mathcal { P } _ { r }$ with support in $[ r _ { m i n } , r _ { m a x } ]$ such that in the limit of infinite training data, ERM using $I P S$ over the logged data $\mathcal D \sim \dot { P } ( \mathcal X ) \times \pi _ { 0 } ( \cdot | \mathcal X ) \times \mathcal P _ { r }$ can select a policy $\begin{array} { r } { \hat { \pi } \in \arg \operatorname* { m a x } _ { \pi \in \Pi } \mathbb { E } _ { \mathcal { D } } [ \hat { R } _ { I P S } ( \pi ) ] } \end{array}$ that is at least $\begin{array} { r l } {  { ( r _ { m a x } - r _ { m i n } ) \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) } \quad } & { { } } \end{array}$ suboptimal.
+
+Proof. For any given hypothesis space $\Pi$ and logging policy $\pi _ { 0 }$ , define a deterministic reward distribution $\mathcal { P } _ { r }$ as the following: for all context $x$ , $r ( x , y ) = \delta ( x , y ) = r _ { m i n }$ for $y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c }$ and $r ( x , y ) ~ = ~ \delta ( x , y ) ~ = ~ r _ { m a x }$ for $y \in \mathcal { U } ( x , \pi _ { 0 } )$ . Let $\tilde { \pi } \in \arg \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } )$ and $\pi ^ { * } \in \arg \operatorname* { m a x } _ { \pi \in \Pi } R ( \pi )$ , then we have the following lower bound for $R ( \pi ^ { * } )$ :
+
+$$
+\begin{array} { r l } & { R ( \pi ^ { * } ) \geq R ( \tilde { \pi } ) } \\ & { \qquad = \underset { x } { \mathbb { E } } [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } r _ { m a x } + \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } r _ { m i n } ] } \\ & { \qquad = r _ { m a x } \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) + r _ { m i n } \big ( 1 - \underset { \pi \in \Pi } { \operatorname* { m a x } } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) \big ) } \end{array}
+$$
+
+where the first inequality follows from the definition of $\pi ^ { * }$ , the first and second equality is based on the specific reward distribution $\mathcal { P } _ { r }$ and the definition of $\tilde { \pi }$ .
+
+In the following we will show that for any $\hat { \pi }$ learned by the expectation of ERM (or in the limit of infinite amount data), i.e., πˆ ∈ arg max $\mathbb { E } _ { \mathcal { D } } [ \hat { R } _ { I P S } ^ { \mathcal { D } } ( \pi ) ]$ , $\hat { \pi }$ have the same support as $\pi _ { 0 }$ .
+
+$$
+\mathbb { E } [ \hat { R } _ { I P S } ( \pi ) ] = \mathbb { E } [ \sum _ { x } \pi ( y | x ) r _ { m i n } ] = r _ { m i n } \mathbb { E } [ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi ( y | x ) ] \le r _ { m i n }
+$$
+
+for all $\pi \in \Pi$ , then it is easy to see $\pi _ { 0 } \in \Pi$ is one of the solution of ERM. Actually for any $\hat { \pi } \in$ arg max $\begin{array} { r } { \mathbb { E } _ { \mathcal { D } } [ \hat { R } _ { I P S } ^ { \mathcal { D } } ( \pi ) ] , \mathbb { E } _ { x } [ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi ( y | x ) ] = 1 } \end{array}$ and it gives us that any solution of the ERM has exactly the same support as $\pi _ { 0 }$ , then we have $R ( \hat { \pi } ) = r _ { m i n }$ for $\hat { \pi } \in \arg \operatorname* { m a x } \mathbb { E } _ { \mathcal { D } } [ \hat { R } _ { I P S } ^ { \mathcal { D } } ( \pi ) ]$ .
+
+Combining the lower bound for $R ( \pi ^ { * } )$ and $R ( \hat { \pi } ) = r _ { m i n }$ , we have
+
+$$
+\begin{array} { r l } & { R ( \pi ^ { * } ) - R ( \hat { \pi } ) \geq r _ { m a x } \displaystyle \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) + r _ { m i n } ( 1 - \displaystyle \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) ) - r _ { m i n } } \\ & { \quad \quad \quad \quad \quad = \left( r _ { m a x } - r _ { m i n } \right) \displaystyle \operatorname* { m a x } _ { \pi \in \Pi } \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) } \end{array}
+$$
+
+# A.3 PROOF OF THEOREM 2
+
+Theorem 2. For contexts $x _ { i }$ drawn i.i.d from $P ( \mathcal X )$ , action $y _ { i }$ drawn from logging policy $\pi _ { 0 }$ , we define SD(π|π0) = 1n Pni=1 π(yi|xi)π0(yi|xi) . For any policy $\pi$ it holds that
+
+$$
+\begin{array} { r } { \underset { x \sim P ( \mathcal { X } ) } { \mathbb { E } } \underset { y \sim \pi _ { 0 } ( \cdot | x ) } { \mathbb { E } } [ S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) ] + \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) = 1 } \end{array}
+$$
+
+Proof.
+
+$$
+\begin{array} { r l } { \underset { x , y \sim \pi _ { 0 } } { \mathbb { E } } [ S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) ] + \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) = \underset { x } { \mathbb { E } } [ \ \underset { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } { \sum } \pi _ { 0 } ( y | x ) \frac { \pi ( y | x ) } { \pi _ { 0 } ( y | x ) } ] + \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) } & { } \\ { = \underset { x } { \mathbb { E } } [ \ \underset { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } { \sum } \pi ( y | x ) ] + \underset { x } { \mathbb { E } } [ \ \underset { y \in \mathcal { U } ( x , \pi _ { 0 } ) } { \sum } \pi ( y | x ) ] } & { } \\ { = \underset { x } { \mathbb { E } } [ \underset { y \in \mathcal { Y } } { \sum } \pi ( y | x ) ] = 1 } & { } \end{array}
+$$
+
+The first equality is based on definition of $S _ { D } ( \pi | \pi _ { 0 } )$ and the second equality is based on definition of support divergence. □
+
+# A.4 PROOF OF PROPOSITION 3
+
+Proposition 3. For any given $\kappa \in ( 0 , 1 )$ , $0 < \epsilon < \kappa / 2$ , let $p _ { m i n }$ denote the minimum propensity under supported set $p _ { m i n } ~ = ~ m a x _ { x , y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi _ { 0 } ( y | x )$ , then with probability larger than $1 - 2 \exp ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } )$ , the constraint $1 - \kappa { + } \epsilon \le S _ { \mathscr { D } } ( \pi | \pi _ { 0 } ) \le 1 { - } \epsilon$ will ensure $0 \leq \mathcal { D } \boldsymbol { x } ( \pi | \pi _ { 0 } ) \leq \kappa$ .
+
+Proof. Recall SD(π|π0) = 1n Pni=1 π(yi|xi)π0(yi|xi) with $( x _ { i } , y _ { i } )$ draw i.i.d from $P ( \mathcal { X } ) \times \pi _ { 0 } ( \mathcal { Y } | \boldsymbol { x } )$ . From Appendix A.3, it is easy to see Ex,y∼π0(·|x)[ π(y|x)π0(y|x) ] $\begin{array} { r } { \mathbb { E } _ { x , y \sim \pi _ { 0 } ( \cdot | x ) } \big [ \frac { \pi ( y | x ) } { \pi _ { 0 } ( y | x ) } \big ] = 1 - \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) } \end{array}$ . Let $p _ { m i n }$ denote the smallest propensity under supported action set, $p _ { m i n } : = \mathrm { m i n } _ { x , y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi _ { 0 } ( y | x ) > 0$ , then the random variable $\frac { \pi ( y | x ) } { \pi _ { 0 } ( y | x ) }$ is strictly bounded between $[ 0 , \frac { 1 } { p _ { m i n } } ]$ . Applying Hoeffding’s bound gives:
+
+$$
+^ { \mathfrak { p } } ( { \mathcal { D } } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) < 1 - S _ { { \mathcal { D } } } ( \pi | \pi _ { 0 } ) - \epsilon ) = \mathbb { P } ( S _ { { \mathcal { D } } } ( \pi | \pi _ { 0 } ) - ( 1 - { \mathcal { D } } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) ) < - \epsilon ) \leq e x p ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } )
+$$
+
+Since $S _ { \mathcal { D } ( \pi | \pi _ { 0 } ) } \le 1 - \epsilon$ gives $1 - S _ { \mathcal { D } } ( \pi \vert \pi _ { 0 } ) - \epsilon \geq 0$ , then we have
+
+$$
+\mathbb { P } ( \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) < 0 ) \le e x p ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } )
+$$
+
+Similar for the other direction, Hoeffding’s bound gives:
+
+$$
+\mathbb { P } ( \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) > 1 - S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) + \epsilon ) = \mathbb { P } ( S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) - ( 1 - \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) ) > \epsilon ) \le e x p ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } )
+$$
+
+Since $S _ { \mathcal { D } ( \pi | \pi _ { 0 } ) } \geq 1 + \epsilon - \kappa$ gives $\begin{array} { r } { 1 - S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) + \epsilon \le \kappa } \end{array}$ , then we have
+
+$$
+\begin{array} { r } { \mathbb { P } ( \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) \ge \kappa ) \le e x p ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } ) } \end{array}
+$$
+
+Combining the above, we have
+
+$$
+\begin{array} { r l } & { \mathbb { P } ( 0 \leq \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) \leq \kappa ) = 1 - \mathbb { P } ( \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) < 0 ) - \mathbb { P } ( \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } ) > \kappa ) } \\ & { \qquad \geq 1 - 2 e x p ( - 2 n \epsilon ^ { 2 } p _ { m i n } ^ { 2 } ) } \end{array}
+$$
+
+# A.5 PROOF FOR EFFICIENT APPROXIMATION
+
+Claim 1. The empirical risk defined by in Equation (8) has the same expectation (over randomness in $\mathcal { D }$ and sampling) as $\hat { R } _ { I P S } ^ { \delta } ( \mathcal { D } )$ .
+
+Proof. Taking the expectation of empirical risk defined in Equation (8):
+
+$$
+\begin{array} { l l } { { \displaystyle { \mathbb E } \big [ \frac { 1 } { n } \sum _ { i = 1 } ^ { n } \frac { \pi \big ( y _ { i } | x _ { i } \big ) } { \pi _ { 0 } \big ( y _ { i } | x _ { i } \big ) } r _ { i } + \frac { 1 } { m } \sum _ { j = 1 } ^ { m } \frac { \pi \big ( y _ { j } | x _ { j } \big ) } { p _ { j } } \hat { \delta } ( x _ { j } , y _ { j } ) \big ] } }  \\ { { \displaystyle { = \mathbb E } \big [ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi _ { 0 } ( y | x ) \frac { \pi \big ( y | x \big ) } { \pi _ { 0 } ( y | x ) } \delta ( x , y ) \big ] + \frac { { \mathbb E } } { x } \big [ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \frac { 1 } { | \mathcal { U } ( x , \pi _ { 0 } ) | } \frac { \pi \big ( y | x \big ) } { \textstyle | \mathcal { U } ( x , \pi _ { 0 } ) | } \hat { \delta } ( x , y ) \big ] } } \\ { { \displaystyle { = \mathbb E } \big [ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi ( y | x ) \delta ( x , y ) \big ] + \frac { { \mathbb E } } { x } \big [ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \hat { \delta } ( x , y ) \big ] } } \end{array}
+$$
+
+Now we will show it has the same expectation with $\hat { R } _ { I P S } ^ { \delta } ( \pi )$
+
+$$
+\begin{array} { r l } & { \frac { \mathbb { E } } { D } \big [ \frac { \pi \big ( y _ { 1 } | x _ { i } \big ) } { \pi _ { 0 } ( y _ { i } | x _ { i } ) } r _ { i } + \displaystyle \sum _ { y \in \mathcal { U } ( x _ { \star } , \pi _ { 0 } ) } \pi ( y | x _ { i } ) \hat { \delta } ( x _ { i } , y ) \big ] } \\ & { = \frac { \mathbb { E } } { x } \big [ \underbrace { \mathbb { E } } _ { y \in \pi _ { 0 } } [ \frac { \pi } { \pi _ { 0 } ( y | x ) } \delta ( x , y ) ] + \displaystyle \sum _ { y ^ { \prime } \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y ^ { \prime } | x ) \hat { \delta } ( x , y ^ { \prime } ) \big ] } \\ & { = \frac { \mathbb { E } } { x } \big [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi _ { 0 } ( y | x ) \frac { \pi ( y | x ) } { \pi _ { 0 } ( y | x ) } \delta ( x , y ) + \displaystyle \sum _ { y ^ { \prime } \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y ^ { \prime } | x ) \hat { \delta } ( x , y ^ { \prime } ) \big ] } \\ & { = \frac { \mathbb { E } } { x } \big [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi ( y | x ) \delta ( x , y ) \big ] + \frac { \mathbb { E } } { x } \big [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \hat { \delta } ( x , y ) \big ] } \end{array}
+$$
+
+The proof is done by comparing Equation (23) and Equation (24).
+
+# A.6 PROOF OF PROPOSITION 2
+
+Proposition 2. Given contexts $x _ { 1 } , x _ { 2 } , \ldots , x _ { n }$ drawn i.i.d from the unknown distribution $P ( \mathcal X )$ , for action $y _ { i }$ drawn independently from logging policy $\pi _ { 0 }$ with probability $\pi _ { 0 } ( \mathcal { V } | x _ { i } )$ , the bias of the empirical risk defined in Equation (7) is $\begin{array} { r } { \mathbb E _ { x } [ \sum _ { y \in \mathcal U _ { x } ^ { \pi _ { 0 } } } \pi ( y | x ) \Delta ( x , y ) ] } \end{array}$ .
+
+Proof. From Appendix A.5, we are given the expectation of $\hat { R } _ { I P S } ^ { \delta } ( \pi )$ , and the bias is:
+
+$$
+\begin{array} { l } { { b i a s ( \hat { R } _ { I P S } ^ { \delta } ( \pi ) ) = { \displaystyle \mathbb { E } } [ \hat { R } _ { I P S } ^ { \delta } ( \pi ) ] - R ( \pi ) } } \\ { ~ = { \displaystyle \frac { { \mathbb { E } } } { x } } \big [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi ( y | x ) \delta ( x , y ) + \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \hat { \delta } ( x , y ) \big ] - R ( \pi ) }  \\ { ~ = { \displaystyle \mathbb { E } } \big [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) ( \hat { \delta } ( x , y ) - \delta ( x , y ) ) \big ] } \\ { ~ = { \displaystyle \mathbb { E } } \big [ \displaystyle \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \Delta ( x , y ) \big ] } \end{array}
+$$
+
+The second equality is from Appendix A.5, the second equality is based on $\begin{array} { r l } { R ( \pi ) } & { { } = } \end{array}$ $\begin{array} { r } { \mathbb { E } _ { x } \left[ \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) ^ { c } } \pi ( y | x ) \delta ( x , y ) + \sum _ { y \in \mathcal { U } ( x , \pi _ { 0 } ) } \pi ( y | x ) \delta ( x , y ) \right] } \end{array}$ , and the last one is based on the definition of $\Delta ( x , y ) : = \hat { \delta } ( x , y ) - \delta ( x , y )$ for all $x \in \mathcal { X } , y \in \mathcal { Y }$ . □
+
+# B APPENDIX: EXPERIMENTS
+
+In this section, we provide the experiment details and additional results to help promote reproducibility of this work.
+
+# B.1 EXPERIMENT SETUP DETAILS
+
+Datasets and baseline. We follow a 75:10:15 train-validation-test split for credit card fraud detection dataset, while for CIFAR10 already coming with a train-test split, we keep $10 \%$ of the training set as validation set. Baseline estimators are IPS and DM, the hyperparameters (learning rate, L2 regularization) are optimized for all the methods based on the validation set.
+
+Bandit data generation. For CIFAR10, given supervised data $\{ x _ { i } , y _ { i } ^ { * } \} _ { i = 1 } ^ { n }$ where $x _ { i }$ denotes the 3072 features and $y _ { i } ^ { * }$ denotes the correct label of data (ranging from 0 to 9), under logging policy $\pi _ { 0 }$ , the logged bandit data is generated by drawing $y _ { i } \sim \pi _ { 0 } ( \mathcal { V } | x _ { i } )$ , then a deterministic reward is defined as $\mathbb { I } _ { \{ y _ { i } = y _ { i } ^ { * } \} }$ . For the credit card fraud detection dataset, we throw away the class label and only use the features for each sample to generate bandit data. To be specific, for each sample with a 28-dimensional feature vector, we define the first 20 features as the contextual information, and use the remaining 8 features as the underlying true reward for 8 different actions (with normalization).
+
+Logging policy. For CIFAR, we learn the softmax logging policy on 35K full-information data points as a multi-class classification problem with cross-entropy loss. Similar as the experiments on BanditNet (Joachims et al., 2018), we adopt the conventional ResNet20 architecture but restrict training after a mere two epochs to derive a relative stochastic policy, since it will be easier to add temperature later to control its stochasticity and support deficiency. Similarly, for the credit card fraud detection dataset, the softmax logging policy is learned on 8K full-information data points by treating it as a multi-class classification problem using cross-entropy loss and the label being the action with the highest reward on this specific context. For CIFAR, the logging policy we trained has a $5 7 . 4 3 \%$ accuracy on the test-set; whereas for the credit card fraud detection dataset, the logging policy has an expected true reward of 0.71.
+
+Reward estimator. For each experiment, we train a different regression function using the full bandit dataset. We use the same architecture as the one used for off-policy learning - where the final layer is the size of the actions, specifying the reward for each action given a particular context. The regression function is trained using the MSE objective.
+
+![](images/51d656734af5ca7eebec76bcca0d315e378aa7a4b913d38454b7164ec98ffb1b.jpg)  
+Figure 4: Behaviour of $S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) + \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } )$
+
+# B.2 SUPPLEMENTARY RESULTS
+
+Reliability of approximating support divergence using control variate. In this experiment, we empirically verify the reliability of estimating support divergence using control variate. The target policy is the uniform policy while the logging policies are varying in their support deficiency. Results are averaged over 10 runs and is shown in Figure 4. We investigate the behaviour of $S _ { \mathcal { D } } ( \pi | \pi _ { 0 } ) + \mathcal { D } _ { \mathcal { X } } ( \pi | \pi _ { 0 } )$ under different number of training data and different support deficiency of the corresponding logging policy. As we can see, the sum converges to 1 as the training data increases. Meanwhile, the variance decreases as shown in the right figure. For different support deficiency curves, the curve converges in a similar fashion and we conjecture it is due to the effect of clipping the propensity at the same threshold $\epsilon = 0 . 0 1$ , which makes $p _ { m i n } = 0 . 0 1$ in the bound shown in Proposition 3.
+
+![](images/2678c7d2bb519d2032262fa6ef15c3ce8481c96bf236def1f54a54d5ca71d2c6.jpg)  
+Figure 5: Model selection result for credit card fraud detection
+
+![](images/217e996b67f6df7a1b4bf8f2cf57d77113d0632e263176148aa1a303192a33e2.jpg)
+
+Model selection comparison for the credit card dataset. The model selection comparison over the credit card fraud detection dataset is demonstrated in Figure 5. Similar as the trend in Figure 3, SNIPS and Conservative Extrapolation exhibit a large bias, also SNIPS even can not reflect the shape of the Oracle curve. DM and Regression Extrapolation closely track the Oracle line, and they have the best performance when used in model selection, as seen in the left table of Figure 5.

parse/train/rygG4AVFvH/rygG4AVFvH.md

@@ -0,0 +1,334 @@
+# CHAMELEON: ADAPTIVE CODE OPTIMIZATION FOR EXPEDITED DEEP NEURAL NETWORK COMPILATION
+
+Byung Hoon $\mathbf { A } \mathbf { h } \mathbf { n } ^ { 1 }$ , Prannoy Pilligundla1, Amir Yazdanbakhsh2, Hadi Esmaeilzadeh1
+
+1 University of California, San Diego   
+2 Google Research   
+bhahn@eng.ucsd.edu, ppilligu@eng.ucsd.edu, ayazdan@google.com   
+hadi@eng.ucsd.edu
+
+# ABSTRACT
+
+Achieving faster execution with shorter compilation time can foster further diversity and innovation in neural networks. However, the current paradigm of executing neural networks either relies on hand-optimized libraries, traditional compilation heuristics, or very recently genetic algorithms and other stochastic methods. These methods suffer from frequent costly hardware measurements rendering them not only too time consuming but also suboptimal. As such, we devise a solution that can learn to quickly adapt to a previously unseen design space for code optimization, both accelerating the search and improving the output performance. This solution dubbed CHAMELEON leverages reinforcement learning whose solution takes fewer steps to converge, and develops an adaptive sampling algorithm that not only focuses on the costly samples (real hardware measurements) on representative points but also uses a domain-knowledge inspired logic to improve the samples itself. Experimentation with real hardware shows that CHAMELEON provides $4 . 4 5 \times$ speed up in optimization time over AutoTVM, while also improving inference time of the modern deep networks by $5 . 6 \%$ .
+
+# 1 INTRODUCTION
+
+The enormous computational intensity of Deep Neural Networks (DNNs) have resulted in developing either hand-optimized kernels, such as NVIDIA cuDNN or Intel MKL that serve as backend for a variety of programming environment such as TensorFlow (Abadi et al., 2016) and PyTorch (Paszke et al., 2019). However, the complexity of the tensor operations in DNNs and the volatility of algorithms, which has led to unprecedented rate of innovation (LeCun, 2019), calls for developing automated compilation frameworks. To imitate or even surpass the success of hand-optimized libraries, recent research has developed stochastic optimization passes: for general code, STOKE (Schkufza et al., 2013), and neural network code, TVM (Chen et al., 2018a) and TensorComprehensions (Vasilache et al., 2018). TVM and TensorComprehensions are based on random or genetic algorithms to search the space of optimized code for neural networks. AutoTVM (Chen et al., 2018b) builds on top of TVM and leverage boosted trees (Chen & Guestrin, 2016) as part of the search cost model to avoid measuring the fitness of each solution (optimized candidate neural network code), and instead predict its fitness. However, even with these innovations the optimizing compilation time can be around 10 hours for ResNet-18 (He et al., 2016), and even more for deeper or wider networks.
+
+Since the general objective is to unleash new possibilities by developing automatic optimization passes, long compilation time hinders innovation and could put the current solutions in a position of questionable utility. To solve this problem, we first question the very statistical guarantees which the aforementioned optimization passes rely on. The current approaches are oblivious to the patterns in the design space of schedules that are available for exploitation, and causes inefficient search or even converges to solutions that may even be suboptimal. Also, we notice that current approaches rely on greedy sampling that neglects the distribution of the candidate solutions (configurations). While greedy sampling that passively filter samples based on the fitness estimations from the cost models work, many of their hardware measurements (required for optimization) tend to be redundant and wasteful. Moreover, we found that current solutions that rely on greedy sampling lead to significant fractions of the candidate configurations being redundant over iterations, and that any optimizing compiler are prone to invalid configurations which significantly prolongs the optimization time. As such, this work sets out to present an Adaptive approach dubbed CHAMELEON to significantly reduce the compilation time and offer automation while avoiding dependence to hand-optimization, enabling far more diverse tensor operations in the next generation DNNs. We tackle this challenge from two fronts with the following contributions:
+
+(1) Devising an Adaptive Exploration module that utilizes reinforcement learning to adapt to unseen design space of new networks to reduce search time yet achieve better performance. (2) Proposing an Adaptive Sampling algorithm that utilizes clustering to adaptively reduce the number of costly hardware measurements, and devising a domain-knowledge inspired Sample Synthesis to find configurations that would potentially yield better performance.
+
+Real hardware experimentation with modern DNNs (AlexNet, VGG-16, and ResNet-18) on a highend GPU (Titan $\mathrm { X p }$ ), shows that the combination of these two innovations, dubbed CHAMELEON, yields $4 . 4 5 \times$ speedup over the leading framework, AutoTVM. CHAMELEON is publicly available in the project page: https://bitbucket.org/act-lab/chameleon.
+
+# 2 CHALLENGES IN DEEP NEURAL NETWORK COMPILATION
+
+The general life-cycle of deep learning models from its birth to deployment comprises of two major stages. First stage is the designing and the training of a deep learning model by a research scientist, with the primary goal of achieving the highest feasible accuracy. Then, with a general demand to enable the intelligence on a wide range of devices (from mobile CPUs in the edge to cloud-scale GPUs), the second stage has emerged for the deployment of the pre-trained deep learning model to a target hardware by a deployment engineer. These stages are each iterative processes: research scientists iterate until it reaches the target performance in terms of accuracy whereas the deployment engineers iterate until the performance in terms of inference speed with a given hardware satisfies the given constraints. Importantly, these two stages are most often separate processes, and this paper mainly focuses on the second stage (deployment) of the cycle with an overarching goal of accelerating the overall deployment cycle by reducing the optimizing compilation time without compromising the performance of the output code.
+
+# 2.1 COMPILATION WORKFLOW FOR DEEP NEURAL NETWORKS
+
+![](images/4c1eda16cc68693383186b7adabf42830ab5f161819979c3ab152bb6ba67eb96.jpg)  
+Figure 1: Overview of our model compilation workflow, and highlighted is the scope of this work.
+
+Figure 1 illustrates how a compiler for DNNs takes an input model $\mathcal { M }$ and emits an optimized code $\tau ( \bar { \Theta } ^ { * } )$ that runs the model efficiently on a given hardware. This flow is commensurate with TensorComprehensions (Vasilache et al., 2018) and TVM (Chen et al., 2018a), using which we implement CHAMELEON that is available as a separate package for adoption in even other frameworks. The first phase of the workflow is the frontend compiler which performs the translation from the compiler and applies target-independent and white-box target-dependent optimizations that do not incorporate a measure of runtime. Target-independent passes transform the input DNN model without specificity to the target hardware. Operator fusion and data layout transformation in TVM are some examples of these passes, which lie in the same category as dead-code elimination or loop-invariant code motion in GCC (Stallman & DeveloperCommunity, 2009) or LLVM (Lattner & Adve, 2004). Target-dependent passes, on the other hand, the compiler takes the hardware architecture (target) into account while optimizing the program; however, this also does not actively leverage runtime measures. The last stage is a black-box optimization pass, called optimizing compiler, that given a measure of performance at runtime from the hardware can further optimize the code. CHAMELEON falls in this class by offering an optimizing compiler that adapts to different design space to be more swift in optimizing deep neural networks compared to conventional approaches.
+
+Table 1: Knobs in the design space to optimize convolution.   
+
+<table><tr><td>KNOBS</td><td>DEFINITION</td></tr><tr><td>tile_f, tile-y, tile_x</td><td>Factors for tiling and binding # of filters height,and width of feature maps.</td></tr><tr><td>tile_rc,tile_ry, tile_rx</td><td>Factors for tiling reduction axis such as # of channels,height,and width of filters.</td></tr><tr><td>auto_unroll_max_step</td><td>Threshold of number of steps in the loop to be automatically unrolled.</td></tr><tr><td>unroll_explicit</td><td>Explicitly unroll loop, this may let code generator to generate pragma unroll hint.</td></tr></table>
+
+![](images/a82336e7fd8660ed1af7676a9258e1f38a623d17fb06729397d666a7e6612433.jpg)  
+Figure 2: AutoTVM optimization time for ResNet-18 on Titan Xp.
+
+# 2.2 OPTIMIZING COMPILER FOR DEEP NEURAL NETWORKS
+
+Optimizing compilers (Kennedy & Allen, 2001) usually take a black-box approach and use hardware measurements to configure the optimization based on a measure of fitness $f$ of each solution. In order to make the problem tractable, the optimizing compilers for deep neural networks reduce the problem down to tuning the knobs $\theta$ for the output code template $\tau$ , and can be formulated as:
+
+$$
+\Theta ^ { * } = \operatorname * { a r g m a x } _ { \Theta } f ( \tau ( \Theta ) ) , \qquad \mathrm { f o r } \Theta \in \mathcal { D } _ { \Theta } .
+$$
+
+A combination of assignment to the knobs is said to be a configuration $\boldsymbol { \Theta } = ( \theta _ { 1 } , \theta _ { 2 } , . . . , \theta _ { n } )$ while the dimensions of the design space $\mathcal { D } _ { \Theta }$ is defined by the knobs. As such, in Equation 1, an optimizing compiler starts from a code template $\tau$ for each layer, and makes use of a search algorithm and real hardware measurements to efficiently find the best configuration $\Theta ^ { \ast } \in { \mathcal { D } } _ { \Theta }$ . In this context, there are three variables that determine the effectiveness of the optimizing compiler: (1) a large and diverse enough design space that covers a variety of transformations, (2) an effective search algorithm to adequately navigate this space, and (3) a mechanism to cut down the number of costly hardware measurements that check the fitness of a solution. Table 1 lists the knobs for performing convolution on a GPU, where it is crucial that the code (1) maximizes data reuse, (2) uses the shared memory wisely, and (3) minimizes bank conflicts. The knobs optimize various aspects of the execution, including tiling (e.g., tile x, tile y, . . . ), unrolling (e.g., auto unroll max step and unroll explicit), and these knobs define a design space with $1 0 ^ { 1 0 }$ possibilities. Given the vastness of the design space, the remaining challenges are designing an effective search algorithm and designing a mechanism that reduces the cost of each step in the search (i.e. reducing the need to measure the hardware).
+
+# 2.3 CHALLENGES IN DEEP NEURAL NETWORK COMPILATION
+
+As shown in Figure 2, optimizing compilation for DNNs may still take an eon even with the advances from prior works (Chen et al., 2018a;b; Vasilache et al., 2018) With active research (You et al., 2017; Goyal et al., 2017; Codreanu et al., 2017; Akiba et al., 2017; You et al., 2018; Mattson et al., 2019) that has been able to cut down the training time to only few hours (You et al., 2017; Goyal et al., 2017) and even minutes (You et al., 2018; Akiba et al., 2017) on big models (e.g., ResNet-50 (He et al., 2016)) for ImageNet, it renders the optimizing compilation time of the current solutions seem even more prominent. Especially, since the above-mentioned compilers have been integrated to the deep learning pipelines of major players in the industry (Liu et al., 2019; Rotem et al., 2018; Vasilache et al., 2018), many users of these pipelines including the deployment engineers must go through the compilation workflow depicted in Figure 1 numerous times. Therefore, current long compilation time can be a hindrance to deploying DNN in various hardware, hence a major bottleneck in enabling intelligence on wider range of target platforms.
+
+Furthermore, as we explore various neural topologies (Xie et al., 2019; Wortsman et al., 2019) for better performance as illustrated in Ahn et al. (2020), even deeper or wider networks (Szegedy et al., 2015; Zagoruyko & Komodakis, 2016), and new operations (Howard et al., 2017) to achieve higher performance (LeCun, 2019), we are forced to optimize the networks more frequently. The long optimization times are multiplied with such trend, leaving the practical utility of the current compiler solutions to question. As such, the primary goal of this work is reducing the optimizing compilation time to meet the immediate needs of the industry for expedited DNN compilation to foster further diversity and innovation in designing DNNs.
+
+![](images/29fcf8d4209155d1093cb560684815d3387661eb22015843e0cbad9b14a22354.jpg)  
+Figure 3: Overall design and compilation overview of the CHAMELEON.
+
+Such long optimization time results from the inefficiency of simulated annealing which (while it stochastically guarantees a reasonable solution after huge number of iterations) fails to capture the patterns in the design space that can be exploited during the search. On the other hand, we can see in the figure that majority of the optimization time is spent on reaching for measurements on real hardware that is used as a feedback for the aforementioned search. Also, current approach even suffers from numerous invalid configurations that not only wastes the limited hardware measurement budget that the compiler starts with, but also incurs serious overhead to reset the target hardware for subsequent hardware measurements. As such, it is important that a sampling mechanism that selects potential configurations for hardware measurements to be smarter to ensure that each measurement is maximizing the chances of achieving a good solution and that it evades the invalid configurations. However, the current approaches rely on greedy sampling that passively sample based on the estimations from the cost models. This not only has a tendency to overfit but also neglect that solutions are distributed non-uniformly and that there are numerous invalid configurations.
+
+# 3 CHAMELEON: ADAPTIVE CODE OPTIMIZATION FOR EXPEDITED DEEP NEURAL NETWORK COMPILATION
+
+As discussed in Section 2, current solutions fall short of providing a swift optimization framework for optimizing emergent deep neural networks, because of the futility of the search in adapting to the design space from a random walk based search algorithm and the inefficiency of the physical hardware measurements from the greedy sampling. Therefore, developing a new framework that can overcome current challenges to unfetter neural network innovation from a prolonged optimization times can be boiled down to two problems: $\textcircled{4}$ improving the the search algorithm to better adapt to the design space, and $\textcircled { \bullet }$ improving the sampling algorithm to both better adapt to the distribution of the solutions and decrease the possibility of running into invalid configurations. As such we make two innovations in the optimizing compiler for deep neural networks to develop CHAMELEON by applying reinforcement learning to the search that can adapt to new design spaces (Adaptive Exploration) and devising an Adaptive Sampling that replaces the current greedy sampling.
+
+# 3.1 OVERALL DESIGN OF CHAMELEON
+
+Figure 3 outlines the overall design of our optimizing compiler, dubbed CHAMELEON1, and gives an overview of the optimizing compilation process. CHAMELEON takes code template $\tau$ for each layer in the network and the corresponding design space $\mathcal { D } _ { \Theta }$ as its input, and iteratively optimizes the code for configuration $\Theta$ to finally output $\tau ( \Theta ^ { * } )$ . The proposed Adaptive Exploration maneuvers the design space while using a cost model as a proxy for hardware measurements to the output set of candidate configurations $S _ { \Theta }$ . These configurations are then sampled with Adaptive Sampling so that the sampled configurations $S _ { \Theta } ^ { \prime }$ subsume the initial candidate configurations while reducing its number significantly. The sampled configurations $S _ { \Theta } ^ { \prime }$ are then passed to the code generator which combines the input template $\tau$ and the configurations $S _ { \Theta } ^ { \prime }$ to create a set of $\tau ( \Theta )$ that are sent to real hardware for runtime measurements. Runtimes from the hardware are used as the measure of fitness $f$ and update the cost model to enhance the exploration of the subsequent iterations. After multiple iterations, $\tau ( \Theta ^ { * } )$ with the best fitness $f$ (shortest runtime) is selected as an output for the layer.
+
+3.2 ADAPTIVE EXPLORATION: LEARNING ABOUT THE UNSEEN DESIGN SPACE TO EXPEDITE CONVERGENCE OF OPTIMIZATION
+
+As stated in Section 2, the current state-of-the-art approach (Chen et al., 2018b) that leverages simulated annealing relies on the stochastic guarantees of its random walks. Therefore, the current approach requires numerous iterations of exploration to converge to a reasonable solution causing long compilation hours, thus insufficient to enable disruptive innovations in neural networks. We take an inspiring approach that avoids naive dependence on the stochastic guarantee of simulated annealing and leverage a technique that can learn to adapt to unseen design space to not only accelerate convergence but also bring some performance gains. As such, we develop Adaptive Exploration by leveraging Reinforcement Learning $( R L )$ , which is concerned with learning to maximize reward given an environment by making good exploration and exploitation tradeoffs, in our case maximizing fitness $f$ of the explored configurations $S _ { \Theta }$ .
+
+Reinforcement learning formulation. Our RL-based Adaptive Exploration module uses an actor-critic style $R L$ , where policy network learns to emit a set of directions (vector of increment/decrement/stay) for each knob in the design space that will increase $f$ of the next configuration and the value network learns the design space $\mathcal { D } _ { \Theta }$ to estimate the value of the action. The first layer of these networks that takes the current configuration $\Theta$ as input is shared to foster information sharing among the two networks, and its output is fed into the subsequent layers the networks. These networks not only learn the dependencies among the different knobs of the design space (which are interrelated) that helps our module navigate through the design space but also lean the potential gains of the modifications to the configurations.
+
+![](images/97d024af12ac3c4f745d8b752f71ea358c4b67e85da0a104058710f13b015c4e.jpg)  
+Figure 4: Adaptive Exploration Module of CHAMELEON in action.
+
+Learning procedure. Having formulated the RL-based Adaptive Exploration Module, an iteration of our optimization begins with a set of initial configurations and takes multiple search steps (episode) for each of the configurations. As shown in Figure 4, the agent makes an action and applies it to the configuration using configuration updater to get another configuration that potentially has better $f$ . After finishing multiple search steps in the episode, all configurations $S _ { \Theta }$ are evaluated using a cost model, which its return values are used as a surrogate reward to update our agent, to reduce the number of costly hardware measurements. By taking this approach, $f$ of $S _ { \Theta }$ improves as our module progresses through the episodes. In other words, by repeating multiple episodes and iterations, our Adaptive Exploration Module gradually learns to locate good configurations.
+
+# 3.3 ADAPTIVE SAMPLING: ADAPTING TO THE DISTRIBUTION TO REDUCE COSTLY HARDWARE MEASUREMENTS
+
+Reducing number of costly hardware measurements. After the exploration step (regardless of the exploration method), we observe that the candidate configurations are clustered in subregions of the design space and these clusters are non-uniformly distributed (Figure 5). We also find that, while the design space’s surface is discrete and un-smooth, a large fraction of configurations within each cluster achieve similar runtime (Figure 6). Utilizing these characteristics of the design space, we devise Adaptive Sampling that can sample a new set of candidates, by adapting to the shape of the design space and the non-uniformity of the distribution while leaving the performance of optimization intact. We first leverage clustering algorithm to find configurations that are representative of each cluster; the sampling module uses centroids as the representative configurations. Our Adaptive Sampling iterates over a different number of clusters for their respective centroids and the L2 loss.
+
+![](images/ed941247342c26d8e1fad3ef4dd55690ccc085092361400e5fd016f0b22e4c39.jpg)  
+Figure 5: Clusters of candidate configurations.
+
+![](images/d9a9b79e18493ca91b94c446e32aee7cb3ed27107e9f4a93ee28dc4354aa45ac.jpg)  
+Figure 6: Cumulative Distribution Function (CDF) of the difference in runtime among the configurations in the cluster.
+
+In the context of optimizing compiler, selecting the number of centroids for clustering entails making the important tradeoff between selecting more centroids for better performance or fewer centroids for a reduced number of hardware measurements. As such, we must devise a method that would automatically make the tradeoff in a reasonable manner. We take advantage of the decreasing trend in the aforementioned L2 loss as we increase the number of centroids, and devise a Threshold-based Swift Meta-Search to determine the number of clusters. By setting the threshold (hyperparameter) it allows the compiler to determine the point of diminishing return (knee of the curve), inflection point beyond which fewer centroids may lead to performance degradation and more clusters would prolong the optimization substantially. Overall, our sampling curtails the number of hardware measurements so that it is just enough to subsume the entire subspace of the candidate configurations.
+
+Improving candidate configurations using sample synthesis. While the above sampling algorithm significantly reduces the number of hardware measurements compared to the conventional greedy sampling, without impacting the performance of the output code, we are still left with a critical issue of redundancy among the candidate configurations. We find that the exploration algorithm (regardless of the type) combined with the greedy sampling frequently leads to redundancy among the candidate configurations over different iterations of optimization due to the overfitting of the cost model from the greediness of the sampling. Even though the exploration algorithm tries to explore unvisited regions of the design space, these explored (not exploited) configurations are discarded due to the greedy sampling which entirely depends on the cost model for its selections of the configurations. Therefore, the current greedy sampling algorithm has its limitation in focusing the hardware measurements to the same region over and over.
+
+On the other hand, we find that from a code optimization point of view, we know that many of the automated approaches for black-box optimization are prone to invalid configurations, which results from too large a tile that goes over the input feature map boundary or errors during memory accesses (cannot be solved analytically). These invalid configurations not only blow the chances for better exploration but also leads to an extra optimization time overhead to reset the physical hardware for the subsequent hardware measurement. We try to overcome both of these limitations by devising Sample Synthesis. When our compiler runs into redundant samples, the proposed synthesis method analyzes the candidate samples to determine the most probable (most frequent $=$ mode function) non-invalid choice for each knob to come up with a new configuration. This statistical combination of the most frequent knob settings yield configurations that combine the strengths of different knobs to converge to a better overall solution. In spirit, the recombination (crossover) operator in genetic algorithms also tries to combine the best features of the solutions with high fitness values. Algorithm 1 presents the integration of our Adaptive Sampling and the Sample Synthesis.
+
+# 3.4 IMPLEMENTATION DETAILS
+
+Architecture exploration for the adaptive exploration. We use Proximal Policy Optimization $( P P O )$ (Schulman et al., 2017), a policy gradient that has been shown to adapt to various problems and have good sample complexity, as our reinforcement learning algorithm. Since reinforcement learning could incur computational overhead that could prolong the optimization time, we optimize the actor-critic networks through architecture exploration to find good tradeoff for size of these networks (that determines the computational overhead) and the optimization performance.
+
+Algorithm 1 Adaptive Sampling and Sample Synthesis   
+
+<table><tr><td>1:</td><td> procedure ADAPTIVESAMPLING(SΘ, UΘ)</td></tr><tr><td>2:</td><td>V se: candidate configs, ve: visited configs new_candidates ← @,previous_loss ←0</td></tr><tr><td>3:</td><td>for k in range(8, 64) do</td></tr><tr><td>4:</td><td>new_candidates,clusters,L2_loss ← K-means.run(se,k)</td></tr><tr><td>5:</td><td>if Threshold × L2_loss ≥ previous_loss then break&gt;Exit loop at knee of loss curve</td></tr><tr><td>6:</td><td>previous_loss ←L2_loss</td></tr><tr><td>7:</td><td>end for</td></tr><tr><td>8:</td><td>for candidate in new_candidates do Replace visited config with new config</td></tr><tr><td>9:</td><td>if candidate in ve then new_candidates.replace(candidate, mode(s@))</td></tr><tr><td>10:</td><td>end for</td></tr><tr><td>11:</td><td>return new_candidates &gt;Feed to Code Generator to make measurements on hardware end procedure</td></tr></table>
+
+Design choices for the adaptive sampling. We use a $\kappa$ -means Clustering to determine centroids of the configurations, because $\kappa$ -means has been shown effective in practice and it only requires $\kappa$ , over error $\epsilon$ or radius in other algorithms which are much more challenging to tune. For example, DBSCAN (Ester et al., 1996) or mean-shift clustering (Comaniciu & Meer, 2002) are very sensitive to the above hyperparameters. On the other hand, $\kappa$ can be framed as a lever to balance the performance and speed of optimizing compilation which abstracts away the aforementioned challenges, enabling the Threshold-based Swift Meta-Search that identifies the optimal number of clusters.
+
+Hyperparameter tuning. Hyperparameter tuning is a very important task in machine learningbased tools and models. As such, we present the hyperparameters we used for the evaluation in Table 7 (in appendix), which its tuning took several days. For the hyperparameters in Table 8 (in appendix), we used the same set of values that were used in the AutoTVM paper (Chen et al., 2018b) in order to conduct a fair comparison or CHAMELEON. Additionally, for parameters used in the Adaptive Exploration module, which is not present in AutoTVM, we have tuned the hyperparameters using the set of layers presented in Table 5 (in appendix). We emphasize, however, that the hyperparameters have been tuned offline before the deployment of CHAMELEON, and the hyperparameters are not changed during the use of the framework or the experimentation. So the tuning overhead is not part of the compilation after the Adaptive Exploration module is tuned once before releasing the compiler to the deployment practitioners.
+
+# 4 EVALUATION
+
+We integrate CHAMELEON into TVM (Chen et al., 2018a) to perform component evaluation and compare with AutoTVM (Chen et al., 2018b). We first evaluate components of CHAMELEON in Section 4.1 and Section 4.2 on set of convolution layers sampled from AlexNet (Krizhevsky et al., 2012), VGG-16 (Simonyan & Zisserman, 2015), and ResNet-18 (He et al., 2016). Then we provide end-to-end evaluation of CHAMELEON on both set of layers and end-to-end deep models, in Section 4.3. Due to space limitations, we present only the representative plots in the paper, and the complete set of results and the details of the parameters are provided in the appendix.
+
+4.1 ADAPTIVE EXPLORATION: IMPROVING EFFICACY OF SEARCH ALGORITHM
+
+In the previous approach (Chen et al., 2018b), authors have built a cost model to estimate fitness instead of performing costly measurements on real hardware, then used simulated annealing to find potentially optimal configurations. Figure 7(a) compares the number of search steps taken per iteration to reach or converge to the solution in simulated annealing and Adaptive Exploration, respectively. Overall, observation is that CHAMELEON’s Adaptive Exploration requires $2 . 8 8 \times$ less search steps compared to simulated annealing to find good solution. This comes from the ability of the reinforcement learning algorithm in Adaptive Exploration Module to (1) learn the correlation between different dimensions, and (2) reuse information across different iterations, instead of starting from scratch while naively relying on the stochastic guarantees of simulated annealing process.
+
+![](images/9ad0ad2777e161304155b61c563bcb6dbb86606a4be75504fda18bc6925fd81c.jpg)  
+Figure 7: Component evaluation of CHAMELEON.
+
+# 4.2 ADAPTIVE SAMPLING: REDUCING NUMBER OF COSTLY HARDWARE MEASUREMENTS
+
+Figure 7(b) summarizes the effect of applying CHAMELEON’s Adaptive Sampling module on simulated annealing and reinforcement learning based search. First, the results show that using Adaptive Sampling helps the framework to make less hardware measurements regardless of the search algorithm used. The Adaptive Sampling algorithm reduces the number of measurements by $1 . 9 8 \times$ when used with simulated annealing and $2 . 3 3 \times$ with reinforcement learning One observation is that the Adaptive Sampling is more effective with reinforcement learning search. This comes from the reinforcement learning agent’s capacity to better localize the search to meaningful samples (exploitation) while still aiming to find good solution by making diverse search (exploration).
+
+Diversity exploration of AutoTVM aims to spread out the candidate configurations with a regularizing effect that fosters uniform sampling. In contrast, our Adaptive Sampling uses a clustering algorithm to perform more measurements on the regions with higher likelihood of achieving better output performance, leading to a non-uniform sampling. While AutoTVM states that diversity-aware selection had no meaningful impact on
+
+![](images/80fe02a72091d19f2baf576de93c71118e759109eb64c4eccd2ecdfc04c1cc03.jpg)  
+Figure 8: Comparison to AutoTVM’s diversity exploration.
+
+most of the evaluated workloads, our Adaptive Sampling brings significant improvement as depicted in Figure 8. As shown, Adaptive Sampling brings an average of $1 3 . 5 \%$ and $1 9 . 0 \%$ improvement on simulated annealing and reinforcement learning, respectively.
+
+# 4.3 INTEGRATION: REDUCING OPTIMIZATION TIME AND OUTPUT INFERENCE TIME
+
+CHAMELEON integrates two components into the workflow: RL-based Adaptive Exploration (AE) and Adaptive Sampling (AS). This section compares the performance of CHAMELEON with AutoTVM (Chen et al., 2018b) that leverages Simulated Annealing (SA) for its exploration.
+
+Layer evaluation. Figure 9 shows the trend of output code performance of ResNet-18’s 11th layer over number of hardware measurements during optimization. The figure illustrates that our Adaptive Exploration finds better configurations than simulated annealing which results in better output code performance, and the Adaptive Sampling reduces number of hardware measurements significantly during optimization. Also, CHAMELEON’s Adaptive Exploration and Adaptive Sampling working in tandem emits better code with shorter optimization time than others. As such, Figure 10(a) compares optimization time and the performance of the output code in CHAMELEON and AutoTVM to confirm the observation. CHAMELEON achieved $1 . 1 7 \times$ better performance with $4 . 8 2 \times$ shorter optimization time compared to AutoTVM. Overall, the results suggest that our Adaptive Exploration effectively maneuvers the design space, and Adaptive Sampling reduces hardware measurements and the overall optimization time while even improving output performance.
+
+![](images/902919044cc53df38e045268760dae15b3b4e717f01247ba0a622d6db4bdd025.jpg)  
+Figure 9: Layer evaluation of output performance for ResNet-18’s 11th layer.
+
+HAMELEON significantly reduces number of hardware measurements (from 800 to 392)   
+
+<table><tr><td>NETWORK</td><td>SA (AutoTVM)</td><td>AE</td><td>SA + AS</td><td>AE+ AS (CHAMELEON)</td></tr><tr><td>AlexNet</td><td>4.31 Hours</td><td>4.06 Hours</td><td>1.25 Hours</td><td>1.20 Hours</td></tr><tr><td>VGG-16</td><td>11.18 Hours</td><td>8.82 Hours</td><td>2.57 Hours</td><td>1.95 Hours</td></tr><tr><td>ResNet-18</td><td>9.13 Hours</td><td>7.39 Hours</td><td>2.14 Hours</td><td>2.13 Hours</td></tr></table>
+
+End-to-end evaluation. Up until now, we have focused on evaluation with subset of layers. Now we continue our discussion to the applicability of CHAMELEON to optimization of end-to-end deep neural networks. Figure 10(b) shows that CHAMELEON spends $3 . 5 9 \times$ , $5 . 7 3 \times$ , and $4 . 2 8 \times$ less time than AutoTVM to optimize AlexNet, VGG-16, and ResNet-18, respectively. On average, our work shows $4 . 4 5 \times$ optimization time speedup while achieving up to $6 . 4 \%$ improvement in terms of performance of output code. Inference time in Figure 10(b) illustrates the speedup for optimized code. Raw numbers are available in Table 2 and Table 3. All in all, such improvements result from efficient Adaptive Exploration and the reduced number of hardware measurements from Adaptive Sampling.
+
+![](images/5bd4f96ac9884f3aa4fdc206e0be0d33f6da796de011e9711d54ecc3131f0c4e.jpg)  
+Figure 10: Layer and end-to-end evaluation. Dashed lines denote AutoTVM’s performance.
+
+Table 2: End-to-end evaluation of the optimization time for deep networks.   
+
+<table><tr><td>NETWORK</td><td>SA (AutoTVM)</td><td>AE</td><td>SA + AS</td><td>AE +AS (CHAMELEON)</td></tr><tr><td>AlexNet</td><td>1.0277 ms</td><td>1.0207 ms</td><td>0.9762 ms</td><td>0.9673 ms</td></tr><tr><td>VGG-16</td><td>3.9829 ms</td><td>3.9710 ms</td><td>3.8733 ms</td><td>3.8458 ms</td></tr><tr><td>ResNet-18</td><td>1.0258 ms</td><td>0.9897 ms</td><td>0.9897 ms</td><td>0.9831 ms</td></tr></table>
+
+Table 3: End-to-end evaluation of the output performance for deep networks.
+
+# 5 RELATED WORKS
+
+CHAMELEON uniquely offers a solution that exclusively enables (i) Reinforcement Learning and (ii) Sampling in the context of (iii) Optimizing Compilers for neural networks. As such, we discuss the related work from each of the three independent research directions.
+
+Optimizing compilers. TensorComprehensions (Vasilache et al., 2018) and TVM (Chen et al., 2018a) use genetic algorithm and simulated annealing to choose parameters of polyhedral optimization for neural networks. In a more general context, some computing libraries (Whaley & Dongarra, 1998; Frigo & Johnson, 1998) make use of black box optimization and also profiling-based compilation passes (Chang et al., 1991; Novillo, 2014) utilize runtime information to generate optimized code. Later, AutoTVM (Chen et al., 2018b) incorporates learning with boosted trees within the cost model for TVM to reduce the number of real hardware measurements. While CHAMELEON is inspired and builds on these prior works, unlike them, it is based on reinforcement learning for Adaptive Exploration, and Adaptive Sampling that leverages clustering to reduce the number of measurements.
+
+Reinforcement learning for hyper-parameter optimization. There are a growing body of studies on using reinforcement learning to perform various optimizations (Gao et al., 2018; Mirhoseini et al., 2017; Nareyek, 2003; Mao et al., 2016; Xu et al., 2018; Mao et al., 2019) for a variety of objectives including hyper-parameter optimization for neural networks. For instance, DeepArchitect (Negrinho & Gordon, 2017) and NAS (Zoph & Le, 2017) use reinforcement learning to automate the process of designing deep neural network models and their associated parameters. HAQ (Wang et al., 2019) and ReLeQ (Elthakeb et al., 2018) use reinforcement learning to chose levels of quantization for the layers of a given deep neural network. AMC (He et al., 2018) formulates neural network compression as a RL problem. A most recent effort (Paliwal et al., 2020)–which will be published concurrent to ours in ICLR 2020–combined RL with graph neural networks and genetic algorithms to optimize DNN execution. Our work exclusively explores a different problem, that is optimizing compilers using reinforcement learning.
+
+Sampling algorithms for learning. Active learning is a broad field (Settles, 2009; Cohn et al., 1996; Sugiyama, 2006; Cai et al., 2013; Goetz et al., 2018; Wu et al., 2019) that uses a measure of the change in the model to decide which training data elements should be used to update the model. Passive learning (Yu & Kim, 2010; O’Neill et al., 2017) is an alternative view that independent of the model, analyze the distribution of the training data set and selects a subset. The Adaptive Sampling algorithm for CHAMELEON shares similarities with Passive learning but it differs in its context. The sampling is designed to reduce the number of samples (configuration) for hardware measurement from the exploration of the design space whilst performing an optimization to accelerate the process.
+
+# 6 CONCLUSION
+
+We present CHAMELEON to allow optimizing compilers to adapt to unseen design spaces of code schedules to reduce the optimization time. This paper is also an initial effort to bring reinforcement learning to the realm of optimizing compilers for neural networks, and we also develop an Adaptive Sampling with domain-knowledge inspired Sample Synthesis to not only reduce the number of samples required to navigate the design space but also augment its quality in terms of fitness. Experimentation with real-world deep models shows that CHAMELEON not only reduces the time for compilation significantly, but also improves the quality of the code. This encouraging result suggests a significant potential for various learning techniques to optimizing deep learning models.
+
+# ACKNOWLEDGEMENT
+
+We thank the anonymous reviewers for their insightful comments. We also thank Jinwon Lee and Jangho Kim for the fruitful discussions and feedbacks on the manuscript. This work was in part supported by generous gifts from Qualcomm, Google, Microsoft, and Xilinx as well as the Semiconductor Research Corporation (SRC) contract #2019-SD-2884, National Science Foundation (NSF) awards CNS#1703812, ECCS#1609823, CCF#1553192, Air Force Office of Scientific Research (AFOSR) Young Investigator Program (YIP) award #FA9550-17-1-0274, National Institute of Health (NIH) award #R01EB028350, and Air Force Research Laboratory (AFRL) and Defense Advanced Research Project Agency (DARPA) under agreement number #FA8650-20-2-7009. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of AFRL, DARPA or the U.S. Government.
+
+# REFERENCES
+
+Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. TensorFlow: A system for large-scale machine learning. In OSDI, 2016.
+
+Byung Hoon Ahn, Jinwon Lee, Jamie Menjay Lin, Hsin-Pai Cheng, Jilei Hou, and Hadi Esmaeilzadeh. Ordering chaos: Memory-aware scheduling of irregularly wired neural networks for edge devices. In MLSys, 2020.
+
+Takuya Akiba, Shuji Suzuki, and Keisuke Fukuda. Extremely large minibatch SGD: training ResNet-50 on ImageNet in 15 minutes. arXiv, 2017. URL https://arxiv.org/pdf/1711.04325.pdf.
+
+Wenbin Cai, Ya Zhang, and Jun Zhou. Maximizing expected model change for active learning in regression. In ICDM, 2013.
+
+Pohua P Chang, Scott A Mahlke, and Wen-Mei W Hwu. Using profile information to assist classic code optimizations. Software: Practice and Experience, 1991.
+
+Tianqi Chen and Carlos Guestrin. XGBoost: A scalable tree boosting system. In KDD, 2016.
+
+Tianqi Chen, Thierry Moreau, Ziheng Jiang, Lianmin Zheng, Eddie Yan, Haichen Shen, Meghan Cowan, Leyuan Wang, Yuwei Hu, Luis Ceze, et al. TVM: An automated end-to-end optimizing compiler for deep learning. In OSDI, 2018a.
+
+Tianqi Chen, Lianmin Zheng, Eddie Yan, Ziheng Jiang, Thierry Moreau, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy. Learning to optimize tensor programs. In NeurIPS, 2018b.
+
+Valeriu Codreanu, Damian Podareanu, and Vikram Saletore. Achieving deep learning training in less than 40 minutes on ImageNet-1K & best accuracy and training time on ImageNet-22K & Places-365 with scale-out Intel
+
+David A Cohn, Zoubin Ghahramani, and Michael I Jordan. Active learning with statistical models. JAIR, 1996.
+
+Dorin Comaniciu and Peter Meer. Mean shift: A robust approach toward feature space analysis. TPAMI, 2002.
+
+Ahmed T Elthakeb, Prannoy Pilligundla, Amir Yazdanbakhsh, Sean Kinzer, and Hadi Esmaeilzadeh. ReLeQ: A reinforcement learning approach for deep quantization of neural networks. arXiv, 2018. URL https: //arxiv.org/pdf/1811.01704.pdf.
+
+Martin Ester, Hans-Peter Kriegel, Jorg Sander, and Xiaowei Xu. A density-based algorithm for discovering ¨ clusters a density-based algorithm for discovering clusters in large spatial databases with noise. In KDD, 1996.
+
+Matteo Frigo and Steven G Johnson. FFTW: An adaptive software architecture for the FFT. In ICASSP, 1998.
+
+Yuanxiang Gao, Li Chen, and Baochun Li. Post: Device placement with cross-entropy minimization and proximal policy optimization. In NeurIPS, 2018.
+
+Jack Goetz, Ambuj Tewari, and Paul Zimmerman. Active learning for non-parametric regression using purely random trees. In NeurIPS, 2018.
+
+Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch,´ Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv, 2017. URL https://arxiv.org/pdf/1706.02677.pdf.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.
+
+Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. AMC: AutoML for model compression and acceleration on mobile devices. In ECCV, 2018.
+
+Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. MobileNets: Efficient convolutional neural networks for mobile vision applications. arXiv, 2017. URL https://arxiv.org/pdf/1704.04861.pdf.
+
+Ken Kennedy and John R Allen. Optimizing compilers for modern architectures: a dependence-based approach. Morgan Kaufmann Publishers Inc., 2001.
+
+Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012.
+
+Chris Lattner and Vikram Adve. LLVM: A compilation framework for lifelong program analysis & transformation. In CGO, 2004.
+
+Yann LeCun. Deep learning hardware: Past, present, and future. In ISSCC, 2019.
+
+Yizhi Liu, Yao Wang, Ruofei Yu, Mu Li, Vin Sharma, and Yida Wang. Optimizing CNN model inference on CPUs. In USENIX ATC, 2019.
+
+Hongzi Mao, Mohammad Alizadeh, Ishai Menache, and Srikanth Kandula. Resource management with deep reinforcement learning. In HotNets, 2016.
+
+Hongzi Mao, Malte Schwarzkopf, Shaileshh Bojja Venkatakrishnan, Zili Meng, and Mohammad Alizadeh. Learning scheduling algorithms for data processing clusters. In SIGCOMM, 2019.
+
+Peter Mattson, Christine Cheng, Cody Coleman, Greg Diamos, Paulius Micikevicius, David Patterson, Hanlin Tang, Gu-Yeon Wei, Peter Bailis, Victor Bittorf, et al. MLPerf training benchmark. arXiv, 2019. URL https://arxiv.org/pdf/1910.01500.pdf.
+
+Azalia Mirhoseini, Hieu Pham, Quoc V Le, Benoit Steiner, Rasmus Larsen, Yuefeng Zhou, Naveen Kumar, Mohammad Norouzi, Samy Bengio, and Jeff Dean. Device placement optimization with reinforcement learning. In ICML, 2017.
+
+Alexander Nareyek. Choosing search heuristics by non-stationary reinforcement learning. In Metaheuristics: Computer Decision-Making. Springer, 2003.
+
+Renato Negrinho and Geoff Gordon. DeepArchitect: Automatically designing and training deep architectures. arXiv, 2017. URL https://arxiv.org/pdf/1704.08792.pdf.
+
+Diego Novillo. SamplePGO - the power of profile guided optimizations without the usability burden. In LLVM Compiler Infrastructure in HPC, 2014.
+
+Jack O’Neill, Sarah Jane Delany, and Brian MacNamee. Model-free and model-based active learning for regression. In Advances in Computational Intelligence Systems. Springer, 2017.
+
+Aditya Paliwal, Felix Gimeno, Vinod Nair, Yujia Li, Miles Lubin, Pushmeet Kohli, and Oriol Vinyals. Reinforced genetic algorithm learning for optimizing computation graphs. In ICLR, 2020. URL https: //openreview.net/forum?id $=$ rkxDoJBYPB.
+
+Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. PyTorch: An imperative style, high-performance deep learning library. In NeurIPS, 2019.
+
+Nadav Rotem, Jordan Fix, Saleem Abdulrasool, Garret Catron, Summer Deng, Roman Dzhabarov, Nick Gibson, James Hegeman, Meghan Lele, Roman Levenstein, et al. Glow: Graph lowering compiler techniques for neural networks. arXiv, 2018. URL https://arxiv.org/pdf/1805.00907.pdf.
+
+Eric Schkufza, Rahul Sharma, and Alex Aiken. Stochastic superoptimization. In ASPLOS, 2013.
+
+John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv, 2017. URL https://arxiv.org/pdf/1707.06347.pdf.
+
+Burr Settles. Active learning literature survey. Technical report, University of Wisconsin-Madison Department of Computer Sciences, 2009.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015.
+
+Richard M Stallman and GCC DeveloperCommunity. Using the GNU compiler collection: a GNU manual for GCC version 4.3.3. CreateSpace, 2009.
+
+Masashi Sugiyama. Active learning in approximately linear regression based on conditional expectation of generalization error. JMLR, 2006.
+
+Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, 2015.
+
+Nicolas Vasilache, Oleksandr Zinenko, Theodoros Theodoridis, Priya Goyal, Zachary DeVito, William S Moses, Sven Verdoolaege, Andrew Adams, and Albert Cohen. Tensor Comprehensions: Frameworkagnostic high-performance machine learning abstractions. arXiv, 2018. URL https://arxiv.org/ pdf/1802.04730.pdf.
+
+Kuan Wang, Zhijian Liu, Yujun Lin, Ji Lin, and Song Han. HAQ: Hardware-aware automated quantization with mixed precision. In CVPR, 2019.
+
+R Clinton Whaley and Jack J Dongarra. Automatically tuned linear algebra software. In SC, 1998.
+
+Mitchell Wortsman, Ali Farhadi, and Mohammad Rastegari. Discovering neural wirings. In NeurIPS, 2019.
+
+Dongrui Wu, Chin-Teng Lin, and Jian Huang. Active learning for regression using greedy sampling. Information Sciences, 2019.
+
+Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring randomly wired neural networks for image recognition. In ICCV, 2019.
+
+Zhongwen Xu, Hado P van Hasselt, and David Silver. Meta-gradient reinforcement learning. In NeurIPS, 2018.
+
+Yang You, Igor Gitman, and Boris Ginsburg. Large batch training of convolutional networks. arXiv, 2017. URL https://arxiv.org/pdf/1708.03888.pdf.
+
+Yang You, Zhao Zhang, Cho-Jui Hsieh, James Demmel, and Kurt Keutzer. ImageNet training in minutes. In ICPP, 2018.
+
+Hwanjo Yu and Sungchul Kim. Passive sampling for regression. In ICDM, 2010.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016.
+
+Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. ICLR, 2017. URL https://openreview.net/forum?id $=$ r1Ue8Hcxg.
+
+# APPENDIX
+
+A EXPERIMENTAL SETUP
+
+A.1 DNN MODELS AND LAYERS
+
+Table 4: Details of the DNN models used in evaluating CHAMELEON.   
+
+<table><tr><td>NETWORK</td><td>DATASET</td><td>NUMBER OF TASKS</td></tr><tr><td>AlexNet</td><td>ImageNet</td><td>5</td></tr><tr><td>VGG-16</td><td>ImageNet</td><td>9</td></tr><tr><td>ResNet-18</td><td>ImageNet</td><td>12</td></tr></table>
+
+Table 5: Details of the layers used in evaluating CHAMELEON.   
+
+<table><tr><td>NAME</td><td>MODEL</td><td>LAYER TYPE</td><td>TASK INDEX</td></tr><tr><td>L1</td><td>AlexNet</td><td>convolution</td><td>1</td></tr><tr><td>L2</td><td>AlexNet</td><td>convolution</td><td>4</td></tr><tr><td>L3</td><td>VGG-16</td><td>convolution</td><td>1</td></tr><tr><td>L4</td><td>VGG-16</td><td>convolution</td><td>2</td></tr><tr><td>L5</td><td>VGG-16</td><td>convolution</td><td>4</td></tr><tr><td>L6</td><td>ResNet-18</td><td>convolution</td><td>6</td></tr><tr><td>L7</td><td>ResNet-18</td><td>convolution</td><td>9</td></tr><tr><td>L8</td><td>ResNet-18</td><td>convolution</td><td>11</td></tr></table>
+
+# A.2 HARDWARE SPECIFICATION
+
+Table 6: Details of the hardware used for evaluation of CHAMELEON.   
+
+<table><tr><td>SPECIFICATIONS</td><td>DETAILS</td></tr><tr><td>GPU</td><td>Titan Xp</td></tr><tr><td>Host CPU</td><td>3.4G Hz Intel Core i7</td></tr><tr><td>Main Memory</td><td>32GB 2400 MHz DDR3</td></tr></table>
+
+# A.3 HYPER-PARAMETERS
+
+Table 7: Hyper-parameters uses in CHAMELEON.   
+
+<table><tr><td>HYPERPARAMETER</td><td>VALUE</td><td>DESCRIPTION</td></tr><tr><td>iterationopt</td><td>16</td><td>number of iterations for optimization process (equivalent to 1Ooo hardware measurements)</td></tr><tr><td>modeGBT bGBT</td><td>xgb-reg</td><td>type of loss used for cost model</td></tr><tr><td></td><td>64</td><td>maximum batch size of planning in GBT(Chen &amp; Guestrin,2016) cost model per iteration of optimization process</td></tr><tr><td>episoderl</td><td>128</td><td>number of episodes for reinforcement learning</td></tr><tr><td>steprl</td><td>500</td><td>maximum steps of one reinforcement learning episode</td></tr><tr><td>thresholdmeta</td><td>2.5</td><td>threshold used for meta-search in sampling</td></tr><tr><td></td><td></td><td></td></tr></table>
+
+Table 8: Hyper-parameters uses in AutoTVM (Chen et al., 2018b).   
+
+<table><tr><td>HYPERPARAMETER</td><td>VALUE</td><td>DESCRIPTION</td></tr><tr><td>£(bGBT)</td><td>1000</td><td>totalnumber of hardwaremeasurements</td></tr><tr><td>modeGBT</td><td>xgb-reg</td><td>type of loss used for cost model</td></tr><tr><td>bGBT</td><td>64</td><td>batch size of planning in GBT(Chen&amp; Guestrin,2016)</td></tr><tr><td>nsa</td><td>128</td><td>number of Markov chains in parallel simulated annealing</td></tr><tr><td>stepsa</td><td>500</td><td>maximum steps of one simulated annealing run</td></tr></table>
+
+Table 9: Hyper-parameters used in CHAMELEON’s PPO (Schulman et al., 2017) search agent.   
+
+<table><tr><td>HYPERPARAMETER</td><td>VALUE</td></tr><tr><td>Adam Step Size Discount Factor</td><td>1×10-3</td></tr><tr><td>GAE Parameter</td><td>0.9</td></tr><tr><td>Number of Epochs</td><td>0.99</td></tr><tr><td>Clipping Parameter</td><td>3</td></tr><tr><td>Value Coefficient</td><td>0.3</td></tr><tr><td></td><td>1.0</td></tr><tr><td>Entropy Coefficient</td><td>0.1</td></tr></table>
+
+# B ADDITIONAL EXPERIMENTAL RESULTS
+
+# B.1 OPTIMIZATION TIME BREAKDOWN FOR DNN MODELS
+
+![](images/026a53d0d37fc394dbde9ee260ed92631908ad47f92de723d2f9d7a13438b6e1.jpg)  
+Figure 11: AutoTVM optimization time for AlexNet (Krizhevsky et al., 2012) and VGG-16 (Simonyan & Zisserman, 2015), and ResNet-18 (He et al., 2016) on Titan Xp. Numbers in bars denote fraction of time for measurements.
+
+![](images/3c8b2503e8f20893f004a618595f804ee4202bdce892dd2dd37cf5019a6c7a97.jpg)  
+Figure 12: Layer evaluations for AlexNet (Krizhevsky et al., 2012).
+
+![](images/01cae0b30b91a657d3523b35270fbc77354a18f41266d34fb3123c16b6bd7b20.jpg)  
+Figure 13: Layer evaluations for VGG-16 (Simonyan & Zisserman, 2015).
+
+![](images/8d074821723c328e9d090e41a9d4a947aea4d674ac66384eb9bb3c3baedf687b.jpg)  
+Figure 14: Layer evaluations for ResNet-18 (He et al., 2016).

parse/train/rygG4AVFvH/rygG4AVFvH_content_list.json

@@ -0,0 +1,1827 @@
+[
+    {
+        "type": "text",
+        "text": "CHAMELEON: ADAPTIVE CODE OPTIMIZATION FOR EXPEDITED DEEP NEURAL NETWORK COMPILATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            810,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Byung Hoon $\\mathbf { A } \\mathbf { h } \\mathbf { n } ^ { 1 }$ , Prannoy Pilligundla1, Amir Yazdanbakhsh2, Hadi Esmaeilzadeh1 ",
+        "bbox": [
+            184,
+            169,
+            772,
+            185
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 University of California, San Diego   \n2 Google Research   \nbhahn@eng.ucsd.edu, ppilligu@eng.ucsd.edu, ayazdan@google.com   \nhadi@eng.ucsd.edu ",
+        "bbox": [
+            184,
+            185,
+            769,
+            241
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            279,
+            544,
+            294
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Achieving faster execution with shorter compilation time can foster further diversity and innovation in neural networks. However, the current paradigm of executing neural networks either relies on hand-optimized libraries, traditional compilation heuristics, or very recently genetic algorithms and other stochastic methods. These methods suffer from frequent costly hardware measurements rendering them not only too time consuming but also suboptimal. As such, we devise a solution that can learn to quickly adapt to a previously unseen design space for code optimization, both accelerating the search and improving the output performance. This solution dubbed CHAMELEON leverages reinforcement learning whose solution takes fewer steps to converge, and develops an adaptive sampling algorithm that not only focuses on the costly samples (real hardware measurements) on representative points but also uses a domain-knowledge inspired logic to improve the samples itself. Experimentation with real hardware shows that CHAMELEON provides $4 . 4 5 \\times$ speed up in optimization time over AutoTVM, while also improving inference time of the modern deep networks by $5 . 6 \\%$ . ",
+        "bbox": [
+            233,
+            308,
+            764,
+            515
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            539,
+            336,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The enormous computational intensity of Deep Neural Networks (DNNs) have resulted in developing either hand-optimized kernels, such as NVIDIA cuDNN or Intel MKL that serve as backend for a variety of programming environment such as TensorFlow (Abadi et al., 2016) and PyTorch (Paszke et al., 2019). However, the complexity of the tensor operations in DNNs and the volatility of algorithms, which has led to unprecedented rate of innovation (LeCun, 2019), calls for developing automated compilation frameworks. To imitate or even surpass the success of hand-optimized libraries, recent research has developed stochastic optimization passes: for general code, STOKE (Schkufza et al., 2013), and neural network code, TVM (Chen et al., 2018a) and TensorComprehensions (Vasilache et al., 2018). TVM and TensorComprehensions are based on random or genetic algorithms to search the space of optimized code for neural networks. AutoTVM (Chen et al., 2018b) builds on top of TVM and leverage boosted trees (Chen & Guestrin, 2016) as part of the search cost model to avoid measuring the fitness of each solution (optimized candidate neural network code), and instead predict its fitness. However, even with these innovations the optimizing compilation time can be around 10 hours for ResNet-18 (He et al., 2016), and even more for deeper or wider networks. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            763
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Since the general objective is to unleash new possibilities by developing automatic optimization passes, long compilation time hinders innovation and could put the current solutions in a position of questionable utility. To solve this problem, we first question the very statistical guarantees which the aforementioned optimization passes rely on. The current approaches are oblivious to the patterns in the design space of schedules that are available for exploitation, and causes inefficient search or even converges to solutions that may even be suboptimal. Also, we notice that current approaches rely on greedy sampling that neglects the distribution of the candidate solutions (configurations). While greedy sampling that passively filter samples based on the fitness estimations from the cost models work, many of their hardware measurements (required for optimization) tend to be redundant and wasteful. Moreover, we found that current solutions that rely on greedy sampling lead to significant fractions of the candidate configurations being redundant over iterations, and that any optimizing compiler are prone to invalid configurations which significantly prolongs the optimization time. As such, this work sets out to present an Adaptive approach dubbed CHAMELEON to significantly reduce the compilation time and offer automation while avoiding dependence to hand-optimization, enabling far more diverse tensor operations in the next generation DNNs. We tackle this challenge from two fronts with the following contributions: ",
+        "bbox": [
+            174,
+            771,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(1) Devising an Adaptive Exploration module that utilizes reinforcement learning to adapt to unseen design space of new networks to reduce search time yet achieve better performance. (2) Proposing an Adaptive Sampling algorithm that utilizes clustering to adaptively reduce the number of costly hardware measurements, and devising a domain-knowledge inspired Sample Synthesis to find configurations that would potentially yield better performance. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Real hardware experimentation with modern DNNs (AlexNet, VGG-16, and ResNet-18) on a highend GPU (Titan $\\mathrm { X p }$ ), shows that the combination of these two innovations, dubbed CHAMELEON, yields $4 . 4 5 \\times$ speedup over the leading framework, AutoTVM. CHAMELEON is publicly available in the project page: https://bitbucket.org/act-lab/chameleon. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            314
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 CHALLENGES IN DEEP NEURAL NETWORK COMPILATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            687,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The general life-cycle of deep learning models from its birth to deployment comprises of two major stages. First stage is the designing and the training of a deep learning model by a research scientist, with the primary goal of achieving the highest feasible accuracy. Then, with a general demand to enable the intelligence on a wide range of devices (from mobile CPUs in the edge to cloud-scale GPUs), the second stage has emerged for the deployment of the pre-trained deep learning model to a target hardware by a deployment engineer. These stages are each iterative processes: research scientists iterate until it reaches the target performance in terms of accuracy whereas the deployment engineers iterate until the performance in terms of inference speed with a given hardware satisfies the given constraints. Importantly, these two stages are most often separate processes, and this paper mainly focuses on the second stage (deployment) of the cycle with an overarching goal of accelerating the overall deployment cycle by reducing the optimizing compilation time without compromising the performance of the output code. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            544
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 COMPILATION WORKFLOW FOR DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            569,
+            627,
+            583
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/4c1eda16cc68693383186b7adabf42830ab5f161819979c3ab152bb6ba67eb96.jpg",
+        "image_caption": [
+            "Figure 1: Overview of our model compilation workflow, and highlighted is the scope of this work. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            607,
+            753,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Figure 1 illustrates how a compiler for DNNs takes an input model $\\mathcal { M }$ and emits an optimized code $\\tau ( \\bar { \\Theta } ^ { * } )$ that runs the model efficiently on a given hardware. This flow is commensurate with TensorComprehensions (Vasilache et al., 2018) and TVM (Chen et al., 2018a), using which we implement CHAMELEON that is available as a separate package for adoption in even other frameworks. The first phase of the workflow is the frontend compiler which performs the translation from the compiler and applies target-independent and white-box target-dependent optimizations that do not incorporate a measure of runtime. Target-independent passes transform the input DNN model without specificity to the target hardware. Operator fusion and data layout transformation in TVM are some examples of these passes, which lie in the same category as dead-code elimination or loop-invariant code motion in GCC (Stallman & DeveloperCommunity, 2009) or LLVM (Lattner & Adve, 2004). Target-dependent passes, on the other hand, the compiler takes the hardware architecture (target) into account while optimizing the program; however, this also does not actively leverage runtime measures. The last stage is a black-box optimization pass, called optimizing compiler, that given a measure of performance at runtime from the hardware can further optimize the code. CHAMELEON falls in this class by offering an optimizing compiler that adapts to different design space to be more swift in optimizing deep neural networks compared to conventional approaches. ",
+        "bbox": [
+            173,
+            702,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/c2e5a4dd0b08feacfb84d10506f773673ba88a1cd59ac54e25896d4a354d2118.jpg",
+        "table_caption": [
+            "Table 1: Knobs in the design space to optimize convolution. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>KNOBS</td><td>DEFINITION</td></tr><tr><td>tile_f, tile-y, tile_x</td><td>Factors for tiling and binding # of filters height,and width of feature maps.</td></tr><tr><td>tile_rc,tile_ry, tile_rx</td><td>Factors for tiling reduction axis such as # of channels,height,and width of filters.</td></tr><tr><td>auto_unroll_max_step</td><td>Threshold of number of steps in the loop to be automatically unrolled.</td></tr><tr><td>unroll_explicit</td><td>Explicitly unroll loop, this may let code generator to generate pragma unroll hint.</td></tr></table>",
+        "bbox": [
+            194,
+            101,
+            566,
+            231
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/a82336e7fd8660ed1af7676a9258e1f38a623d17fb06729397d666a7e6612433.jpg",
+        "image_caption": [
+            "Figure 2: AutoTVM optimization time for ResNet-18 on Titan Xp. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            601,
+            103,
+            820,
+            223
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 OPTIMIZING COMPILER FOR DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            276,
+            602,
+            291
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Optimizing compilers (Kennedy & Allen, 2001) usually take a black-box approach and use hardware measurements to configure the optimization based on a measure of fitness $f$ of each solution. In order to make the problem tractable, the optimizing compilers for deep neural networks reduce the problem down to tuning the knobs $\\theta$ for the output code template $\\tau$ , and can be formulated as: ",
+        "bbox": [
+            174,
+            303,
+            825,
+            359
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e38bda066d98c27abf8ecce1932f0e2c8e4e10202b43524d3b59987121af43c.jpg",
+        "text": "$$\n\\Theta ^ { * } = \\operatorname * { a r g m a x } _ { \\Theta } f ( \\tau ( \\Theta ) ) , \\qquad \\mathrm { f o r } \\Theta \\in \\mathcal { D } _ { \\Theta } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            366,
+            640,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "A combination of assignment to the knobs is said to be a configuration $\\boldsymbol { \\Theta } = ( \\theta _ { 1 } , \\theta _ { 2 } , . . . , \\theta _ { n } )$ while the dimensions of the design space $\\mathcal { D } _ { \\Theta }$ is defined by the knobs. As such, in Equation 1, an optimizing compiler starts from a code template $\\tau$ for each layer, and makes use of a search algorithm and real hardware measurements to efficiently find the best configuration $\\Theta ^ { \\ast } \\in { \\mathcal { D } } _ { \\Theta }$ . In this context, there are three variables that determine the effectiveness of the optimizing compiler: (1) a large and diverse enough design space that covers a variety of transformations, (2) an effective search algorithm to adequately navigate this space, and (3) a mechanism to cut down the number of costly hardware measurements that check the fitness of a solution. Table 1 lists the knobs for performing convolution on a GPU, where it is crucial that the code (1) maximizes data reuse, (2) uses the shared memory wisely, and (3) minimizes bank conflicts. The knobs optimize various aspects of the execution, including tiling (e.g., tile x, tile y, . . . ), unrolling (e.g., auto unroll max step and unroll explicit), and these knobs define a design space with $1 0 ^ { 1 0 }$ possibilities. Given the vastness of the design space, the remaining challenges are designing an effective search algorithm and designing a mechanism that reduces the cost of each step in the search (i.e. reducing the need to measure the hardware). ",
+        "bbox": [
+            173,
+            400,
+            825,
+            594
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 CHALLENGES IN DEEP NEURAL NETWORK COMPILATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            612,
+            616,
+            627
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 2, optimizing compilation for DNNs may still take an eon even with the advances from prior works (Chen et al., 2018a;b; Vasilache et al., 2018) With active research (You et al., 2017; Goyal et al., 2017; Codreanu et al., 2017; Akiba et al., 2017; You et al., 2018; Mattson et al., 2019) that has been able to cut down the training time to only few hours (You et al., 2017; Goyal et al., 2017) and even minutes (You et al., 2018; Akiba et al., 2017) on big models (e.g., ResNet-50 (He et al., 2016)) for ImageNet, it renders the optimizing compilation time of the current solutions seem even more prominent. Especially, since the above-mentioned compilers have been integrated to the deep learning pipelines of major players in the industry (Liu et al., 2019; Rotem et al., 2018; Vasilache et al., 2018), many users of these pipelines including the deployment engineers must go through the compilation workflow depicted in Figure 1 numerous times. Therefore, current long compilation time can be a hindrance to deploying DNN in various hardware, hence a major bottleneck in enabling intelligence on wider range of target platforms. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            805
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, as we explore various neural topologies (Xie et al., 2019; Wortsman et al., 2019) for better performance as illustrated in Ahn et al. (2020), even deeper or wider networks (Szegedy et al., 2015; Zagoruyko & Komodakis, 2016), and new operations (Howard et al., 2017) to achieve higher performance (LeCun, 2019), we are forced to optimize the networks more frequently. The long optimization times are multiplied with such trend, leaving the practical utility of the current compiler solutions to question. As such, the primary goal of this work is reducing the optimizing compilation time to meet the immediate needs of the industry for expedited DNN compilation to foster further diversity and innovation in designing DNNs. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/29fcf8d4209155d1093cb560684815d3387661eb22015843e0cbad9b14a22354.jpg",
+        "image_caption": [
+            "Figure 3: Overall design and compilation overview of the CHAMELEON. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            236,
+            88,
+            758,
+            243
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Such long optimization time results from the inefficiency of simulated annealing which (while it stochastically guarantees a reasonable solution after huge number of iterations) fails to capture the patterns in the design space that can be exploited during the search. On the other hand, we can see in the figure that majority of the optimization time is spent on reaching for measurements on real hardware that is used as a feedback for the aforementioned search. Also, current approach even suffers from numerous invalid configurations that not only wastes the limited hardware measurement budget that the compiler starts with, but also incurs serious overhead to reset the target hardware for subsequent hardware measurements. As such, it is important that a sampling mechanism that selects potential configurations for hardware measurements to be smarter to ensure that each measurement is maximizing the chances of achieving a good solution and that it evades the invalid configurations. However, the current approaches rely on greedy sampling that passively sample based on the estimations from the cost models. This not only has a tendency to overfit but also neglect that solutions are distributed non-uniformly and that there are numerous invalid configurations. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            468
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3 CHAMELEON: ADAPTIVE CODE OPTIMIZATION FOR EXPEDITED DEEP NEURAL NETWORK COMPILATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            489,
+            637,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Section 2, current solutions fall short of providing a swift optimization framework for optimizing emergent deep neural networks, because of the futility of the search in adapting to the design space from a random walk based search algorithm and the inefficiency of the physical hardware measurements from the greedy sampling. Therefore, developing a new framework that can overcome current challenges to unfetter neural network innovation from a prolonged optimization times can be boiled down to two problems: $\\textcircled{4}$ improving the the search algorithm to better adapt to the design space, and $\\textcircled { \\bullet }$ improving the sampling algorithm to both better adapt to the distribution of the solutions and decrease the possibility of running into invalid configurations. As such we make two innovations in the optimizing compiler for deep neural networks to develop CHAMELEON by applying reinforcement learning to the search that can adapt to new design spaces (Adaptive Exploration) and devising an Adaptive Sampling that replaces the current greedy sampling. ",
+        "bbox": [
+            174,
+            539,
+            825,
+            691
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 OVERALL DESIGN OF CHAMELEON ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            710,
+            459,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 outlines the overall design of our optimizing compiler, dubbed CHAMELEON1, and gives an overview of the optimizing compilation process. CHAMELEON takes code template $\\tau$ for each layer in the network and the corresponding design space $\\mathcal { D } _ { \\Theta }$ as its input, and iteratively optimizes the code for configuration $\\Theta$ to finally output $\\tau ( \\Theta ^ { * } )$ . The proposed Adaptive Exploration maneuvers the design space while using a cost model as a proxy for hardware measurements to the output set of candidate configurations $S _ { \\Theta }$ . These configurations are then sampled with Adaptive Sampling so that the sampled configurations $S _ { \\Theta } ^ { \\prime }$ subsume the initial candidate configurations while reducing its number significantly. The sampled configurations $S _ { \\Theta } ^ { \\prime }$ are then passed to the code generator which combines the input template $\\tau$ and the configurations $S _ { \\Theta } ^ { \\prime }$ to create a set of $\\tau ( \\Theta )$ that are sent to real hardware for runtime measurements. Runtimes from the hardware are used as the measure of fitness $f$ and update the cost model to enhance the exploration of the subsequent iterations. After multiple iterations, $\\tau ( \\Theta ^ { * } )$ with the best fitness $f$ (shortest runtime) is selected as an output for the layer. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 ADAPTIVE EXPLORATION: LEARNING ABOUT THE UNSEEN DESIGN SPACE TO EXPEDITE CONVERGENCE OF OPTIMIZATION ",
+        "bbox": [
+            174,
+            151,
+            758,
+            179
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As stated in Section 2, the current state-of-the-art approach (Chen et al., 2018b) that leverages simulated annealing relies on the stochastic guarantees of its random walks. Therefore, the current approach requires numerous iterations of exploration to converge to a reasonable solution causing long compilation hours, thus insufficient to enable disruptive innovations in neural networks. We take an inspiring approach that avoids naive dependence on the stochastic guarantee of simulated annealing and leverage a technique that can learn to adapt to unseen design space to not only accelerate convergence but also bring some performance gains. As such, we develop Adaptive Exploration by leveraging Reinforcement Learning $( R L )$ , which is concerned with learning to maximize reward given an environment by making good exploration and exploitation tradeoffs, in our case maximizing fitness $f$ of the explored configurations $S _ { \\Theta }$ . ",
+        "bbox": [
+            174,
+            193,
+            825,
+            332
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning formulation. Our RL-based Adaptive Exploration module uses an actor-critic style $R L$ , where policy network learns to emit a set of directions (vector of increment/decrement/stay) for each knob in the design space that will increase $f$ of the next configuration and the value network learns the design space $\\mathcal { D } _ { \\Theta }$ to estimate the value of the action. The first layer of these networks that takes the current configuration $\\Theta$ as input is shared to foster information sharing among the two networks, and its output is fed into the subsequent layers the networks. These networks not only learn the dependencies among the different knobs of the design space (which are interrelated) that helps our module navigate through the design space but also lean the potential gains of the modifications to the configurations. ",
+        "bbox": [
+            174,
+            348,
+            825,
+            474
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/97d024af12ac3c4f745d8b752f71ea358c4b67e85da0a104058710f13b015c4e.jpg",
+        "image_caption": [
+            "Figure 4: Adaptive Exploration Module of CHAMELEON in action. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            489,
+            758,
+            611
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Learning procedure. Having formulated the RL-based Adaptive Exploration Module, an iteration of our optimization begins with a set of initial configurations and takes multiple search steps (episode) for each of the configurations. As shown in Figure 4, the agent makes an action and applies it to the configuration using configuration updater to get another configuration that potentially has better $f$ . After finishing multiple search steps in the episode, all configurations $S _ { \\Theta }$ are evaluated using a cost model, which its return values are used as a surrogate reward to update our agent, to reduce the number of costly hardware measurements. By taking this approach, $f$ of $S _ { \\Theta }$ improves as our module progresses through the episodes. In other words, by repeating multiple episodes and iterations, our Adaptive Exploration Module gradually learns to locate good configurations. ",
+        "bbox": [
+            173,
+            654,
+            825,
+            780
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 ADAPTIVE SAMPLING: ADAPTING TO THE DISTRIBUTION TO REDUCE COSTLY HARDWARE MEASUREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            799,
+            637,
+            827
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Reducing number of costly hardware measurements. After the exploration step (regardless of the exploration method), we observe that the candidate configurations are clustered in subregions of the design space and these clusters are non-uniformly distributed (Figure 5). We also find that, while the design space’s surface is discrete and un-smooth, a large fraction of configurations within each cluster achieve similar runtime (Figure 6). Utilizing these characteristics of the design space, we devise Adaptive Sampling that can sample a new set of candidates, by adapting to the shape of the design space and the non-uniformity of the distribution while leaving the performance of optimization intact. We first leverage clustering algorithm to find configurations that are representative of each cluster; the sampling module uses centroids as the representative configurations. Our Adaptive Sampling iterates over a different number of clusters for their respective centroids and the L2 loss. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ed941247342c26d8e1fad3ef4dd55690ccc085092361400e5fd016f0b22e4c39.jpg",
+        "image_caption": [
+            "Figure 5: Clusters of candidate configurations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            97,
+            482,
+            233
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/d9a9b79e18493ca91b94c446e32aee7cb3ed27107e9f4a93ee28dc4354aa45ac.jpg",
+        "image_caption": [
+            "Figure 6: Cumulative Distribution Function (CDF) of the difference in runtime among the configurations in the cluster. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            509,
+            94,
+            807,
+            208
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            275,
+            825,
+            330
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In the context of optimizing compiler, selecting the number of centroids for clustering entails making the important tradeoff between selecting more centroids for better performance or fewer centroids for a reduced number of hardware measurements. As such, we must devise a method that would automatically make the tradeoff in a reasonable manner. We take advantage of the decreasing trend in the aforementioned L2 loss as we increase the number of centroids, and devise a Threshold-based Swift Meta-Search to determine the number of clusters. By setting the threshold (hyperparameter) it allows the compiler to determine the point of diminishing return (knee of the curve), inflection point beyond which fewer centroids may lead to performance degradation and more clusters would prolong the optimization substantially. Overall, our sampling curtails the number of hardware measurements so that it is just enough to subsume the entire subspace of the candidate configurations. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Improving candidate configurations using sample synthesis. While the above sampling algorithm significantly reduces the number of hardware measurements compared to the conventional greedy sampling, without impacting the performance of the output code, we are still left with a critical issue of redundancy among the candidate configurations. We find that the exploration algorithm (regardless of the type) combined with the greedy sampling frequently leads to redundancy among the candidate configurations over different iterations of optimization due to the overfitting of the cost model from the greediness of the sampling. Even though the exploration algorithm tries to explore unvisited regions of the design space, these explored (not exploited) configurations are discarded due to the greedy sampling which entirely depends on the cost model for its selections of the configurations. Therefore, the current greedy sampling algorithm has its limitation in focusing the hardware measurements to the same region over and over. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            647
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, we find that from a code optimization point of view, we know that many of the automated approaches for black-box optimization are prone to invalid configurations, which results from too large a tile that goes over the input feature map boundary or errors during memory accesses (cannot be solved analytically). These invalid configurations not only blow the chances for better exploration but also leads to an extra optimization time overhead to reset the physical hardware for the subsequent hardware measurement. We try to overcome both of these limitations by devising Sample Synthesis. When our compiler runs into redundant samples, the proposed synthesis method analyzes the candidate samples to determine the most probable (most frequent $=$ mode function) non-invalid choice for each knob to come up with a new configuration. This statistical combination of the most frequent knob settings yield configurations that combine the strengths of different knobs to converge to a better overall solution. In spirit, the recombination (crossover) operator in genetic algorithms also tries to combine the best features of the solutions with high fitness values. Algorithm 1 presents the integration of our Adaptive Sampling and the Sample Synthesis. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            835
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.4 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            854,
+            405,
+            868
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Architecture exploration for the adaptive exploration. We use Proximal Policy Optimization $( P P O )$ (Schulman et al., 2017), a policy gradient that has been shown to adapt to various problems and have good sample complexity, as our reinforcement learning algorithm. Since reinforcement learning could incur computational overhead that could prolong the optimization time, we optimize the actor-critic networks through architecture exploration to find good tradeoff for size of these networks (that determines the computational overhead) and the optimization performance. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/ba0f0c0e5452359556837de8f1e2bbe5e45df9f526c8ffd7fb4dd5761b9f0d1f.jpg",
+        "table_caption": [
+            "Algorithm 1 Adaptive Sampling and Sample Synthesis "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1:</td><td> procedure ADAPTIVESAMPLING(SΘ, UΘ)</td></tr><tr><td>2:</td><td>V se: candidate configs, ve: visited configs new_candidates ← @,previous_loss ←0</td></tr><tr><td>3:</td><td>for k in range(8, 64) do</td></tr><tr><td>4:</td><td>new_candidates,clusters,L2_loss ← K-means.run(se,k)</td></tr><tr><td>5:</td><td>if Threshold × L2_loss ≥ previous_loss then break&gt;Exit loop at knee of loss curve</td></tr><tr><td>6:</td><td>previous_loss ←L2_loss</td></tr><tr><td>7:</td><td>end for</td></tr><tr><td>8:</td><td>for candidate in new_candidates do Replace visited config with new config</td></tr><tr><td>9:</td><td>if candidate in ve then new_candidates.replace(candidate, mode(s@))</td></tr><tr><td>10:</td><td>end for</td></tr><tr><td>11:</td><td>return new_candidates &gt;Feed to Code Generator to make measurements on hardware end procedure</td></tr></table>",
+        "bbox": [
+            178,
+            114,
+            826,
+            291
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            319,
+            825,
+            361
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Design choices for the adaptive sampling. We use a $\\kappa$ -means Clustering to determine centroids of the configurations, because $\\kappa$ -means has been shown effective in practice and it only requires $\\kappa$ , over error $\\epsilon$ or radius in other algorithms which are much more challenging to tune. For example, DBSCAN (Ester et al., 1996) or mean-shift clustering (Comaniciu & Meer, 2002) are very sensitive to the above hyperparameters. On the other hand, $\\kappa$ can be framed as a lever to balance the performance and speed of optimizing compilation which abstracts away the aforementioned challenges, enabling the Threshold-based Swift Meta-Search that identifies the optimal number of clusters. ",
+        "bbox": [
+            174,
+            377,
+            823,
+            474
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Hyperparameter tuning. Hyperparameter tuning is a very important task in machine learningbased tools and models. As such, we present the hyperparameters we used for the evaluation in Table 7 (in appendix), which its tuning took several days. For the hyperparameters in Table 8 (in appendix), we used the same set of values that were used in the AutoTVM paper (Chen et al., 2018b) in order to conduct a fair comparison or CHAMELEON. Additionally, for parameters used in the Adaptive Exploration module, which is not present in AutoTVM, we have tuned the hyperparameters using the set of layers presented in Table 5 (in appendix). We emphasize, however, that the hyperparameters have been tuned offline before the deployment of CHAMELEON, and the hyperparameters are not changed during the use of the framework or the experimentation. So the tuning overhead is not part of the compilation after the Adaptive Exploration module is tuned once before releasing the compiler to the deployment practitioners. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 EVALUATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            666,
+            313,
+            681
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We integrate CHAMELEON into TVM (Chen et al., 2018a) to perform component evaluation and compare with AutoTVM (Chen et al., 2018b). We first evaluate components of CHAMELEON in Section 4.1 and Section 4.2 on set of convolution layers sampled from AlexNet (Krizhevsky et al., 2012), VGG-16 (Simonyan & Zisserman, 2015), and ResNet-18 (He et al., 2016). Then we provide end-to-end evaluation of CHAMELEON on both set of layers and end-to-end deep models, in Section 4.3. Due to space limitations, we present only the representative plots in the paper, and the complete set of results and the details of the parameters are provided in the appendix. ",
+        "bbox": [
+            174,
+            698,
+            825,
+            795
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 ADAPTIVE EXPLORATION: IMPROVING EFFICACY OF SEARCH ALGORITHM ",
+        "bbox": [
+            176,
+            813,
+            733,
+            828
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the previous approach (Chen et al., 2018b), authors have built a cost model to estimate fitness instead of performing costly measurements on real hardware, then used simulated annealing to find potentially optimal configurations. Figure 7(a) compares the number of search steps taken per iteration to reach or converge to the solution in simulated annealing and Adaptive Exploration, respectively. Overall, observation is that CHAMELEON’s Adaptive Exploration requires $2 . 8 8 \\times$ less search steps compared to simulated annealing to find good solution. This comes from the ability of the reinforcement learning algorithm in Adaptive Exploration Module to (1) learn the correlation between different dimensions, and (2) reuse information across different iterations, instead of starting from scratch while naively relying on the stochastic guarantees of simulated annealing process. ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/9ad0ad2777e161304155b61c563bcb6dbb86606a4be75504fda18bc6925fd81c.jpg",
+        "image_caption": [
+            "Figure 7: Component evaluation of CHAMELEON. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            98,
+            821,
+            267
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            300,
+            825,
+            342
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 ADAPTIVE SAMPLING: REDUCING NUMBER OF COSTLY HARDWARE MEASUREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            358,
+            810,
+            373
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Figure 7(b) summarizes the effect of applying CHAMELEON’s Adaptive Sampling module on simulated annealing and reinforcement learning based search. First, the results show that using Adaptive Sampling helps the framework to make less hardware measurements regardless of the search algorithm used. The Adaptive Sampling algorithm reduces the number of measurements by $1 . 9 8 \\times$ when used with simulated annealing and $2 . 3 3 \\times$ with reinforcement learning One observation is that the Adaptive Sampling is more effective with reinforcement learning search. This comes from the reinforcement learning agent’s capacity to better localize the search to meaningful samples (exploitation) while still aiming to find good solution by making diverse search (exploration). ",
+        "bbox": [
+            173,
+            385,
+            825,
+            497
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Diversity exploration of AutoTVM aims to spread out the candidate configurations with a regularizing effect that fosters uniform sampling. In contrast, our Adaptive Sampling uses a clustering algorithm to perform more measurements on the regions with higher likelihood of achieving better output performance, leading to a non-uniform sampling. While AutoTVM states that diversity-aware selection had no meaningful impact on ",
+        "bbox": [
+            174,
+            517,
+            419,
+            683
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/80fe02a72091d19f2baf576de93c71118e759109eb64c4eccd2ecdfc04c1cc03.jpg",
+        "image_caption": [
+            "Figure 8: Comparison to AutoTVM’s diversity exploration. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            446,
+            515,
+            805,
+            656
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "most of the evaluated workloads, our Adaptive Sampling brings significant improvement as depicted in Figure 8. As shown, Adaptive Sampling brings an average of $1 3 . 5 \\%$ and $1 9 . 0 \\%$ improvement on simulated annealing and reinforcement learning, respectively. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            726
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 INTEGRATION: REDUCING OPTIMIZATION TIME AND OUTPUT INFERENCE TIME ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            769,
+            757
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "CHAMELEON integrates two components into the workflow: RL-based Adaptive Exploration (AE) and Adaptive Sampling (AS). This section compares the performance of CHAMELEON with AutoTVM (Chen et al., 2018b) that leverages Simulated Annealing (SA) for its exploration. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            810
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Layer evaluation. Figure 9 shows the trend of output code performance of ResNet-18’s 11th layer over number of hardware measurements during optimization. The figure illustrates that our Adaptive Exploration finds better configurations than simulated annealing which results in better output code performance, and the Adaptive Sampling reduces number of hardware measurements significantly during optimization. Also, CHAMELEON’s Adaptive Exploration and Adaptive Sampling working in tandem emits better code with shorter optimization time than others. As such, Figure 10(a) compares optimization time and the performance of the output code in CHAMELEON and AutoTVM to confirm the observation. CHAMELEON achieved $1 . 1 7 \\times$ better performance with $4 . 8 2 \\times$ shorter optimization time compared to AutoTVM. Overall, the results suggest that our Adaptive Exploration effectively maneuvers the design space, and Adaptive Sampling reduces hardware measurements and the overall optimization time while even improving output performance. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/902919044cc53df38e045268760dae15b3b4e717f01247ba0a622d6db4bdd025.jpg",
+        "image_caption": [
+            "Figure 9: Layer evaluation of output performance for ResNet-18’s 11th layer. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            102,
+            769,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            251,
+            825,
+            306
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/f49f6ccd90c211ab039138d0baab9e8213ca2e227b2b6a5c97fe54adf73f529c.jpg",
+        "table_caption": [
+            "HAMELEON significantly reduces number of hardware measurements (from 800 to 392) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>NETWORK</td><td>SA (AutoTVM)</td><td>AE</td><td>SA + AS</td><td>AE+ AS (CHAMELEON)</td></tr><tr><td>AlexNet</td><td>4.31 Hours</td><td>4.06 Hours</td><td>1.25 Hours</td><td>1.20 Hours</td></tr><tr><td>VGG-16</td><td>11.18 Hours</td><td>8.82 Hours</td><td>2.57 Hours</td><td>1.95 Hours</td></tr><tr><td>ResNet-18</td><td>9.13 Hours</td><td>7.39 Hours</td><td>2.14 Hours</td><td>2.13 Hours</td></tr></table>",
+        "bbox": [
+            274,
+            611,
+            715,
+            690
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "End-to-end evaluation. Up until now, we have focused on evaluation with subset of layers. Now we continue our discussion to the applicability of CHAMELEON to optimization of end-to-end deep neural networks. Figure 10(b) shows that CHAMELEON spends $3 . 5 9 \\times$ , $5 . 7 3 \\times$ , and $4 . 2 8 \\times$ less time than AutoTVM to optimize AlexNet, VGG-16, and ResNet-18, respectively. On average, our work shows $4 . 4 5 \\times$ optimization time speedup while achieving up to $6 . 4 \\%$ improvement in terms of performance of output code. Inference time in Figure 10(b) illustrates the speedup for optimized code. Raw numbers are available in Table 2 and Table 3. All in all, such improvements result from efficient Adaptive Exploration and the reduced number of hardware measurements from Adaptive Sampling. ",
+        "bbox": [
+            173,
+            321,
+            825,
+            434
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/5bd4f96ac9884f3aa4fdc206e0be0d33f6da796de011e9711d54ecc3131f0c4e.jpg",
+        "image_caption": [
+            "Figure 10: Layer and end-to-end evaluation. Dashed lines denote AutoTVM’s performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            445,
+            810,
+            578
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/ca70579f4f7091141d0d39ecf57f6ae73c519db2a2fc82ce4327c505a2be72a1.jpg",
+        "table_caption": [
+            "Table 2: End-to-end evaluation of the optimization time for deep networks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>NETWORK</td><td>SA (AutoTVM)</td><td>AE</td><td>SA + AS</td><td>AE +AS (CHAMELEON)</td></tr><tr><td>AlexNet</td><td>1.0277 ms</td><td>1.0207 ms</td><td>0.9762 ms</td><td>0.9673 ms</td></tr><tr><td>VGG-16</td><td>3.9829 ms</td><td>3.9710 ms</td><td>3.8733 ms</td><td>3.8458 ms</td></tr><tr><td>ResNet-18</td><td>1.0258 ms</td><td>0.9897 ms</td><td>0.9897 ms</td><td>0.9831 ms</td></tr></table>",
+        "bbox": [
+            282,
+            728,
+            709,
+            809
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 3: End-to-end evaluation of the output performance for deep networks. ",
+        "bbox": [
+            246,
+            819,
+            750,
+            833
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            354,
+            866
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "CHAMELEON uniquely offers a solution that exclusively enables (i) Reinforcement Learning and (ii) Sampling in the context of (iii) Optimizing Compilers for neural networks. As such, we discuss the related work from each of the three independent research directions. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Optimizing compilers. TensorComprehensions (Vasilache et al., 2018) and TVM (Chen et al., 2018a) use genetic algorithm and simulated annealing to choose parameters of polyhedral optimization for neural networks. In a more general context, some computing libraries (Whaley & Dongarra, 1998; Frigo & Johnson, 1998) make use of black box optimization and also profiling-based compilation passes (Chang et al., 1991; Novillo, 2014) utilize runtime information to generate optimized code. Later, AutoTVM (Chen et al., 2018b) incorporates learning with boosted trees within the cost model for TVM to reduce the number of real hardware measurements. While CHAMELEON is inspired and builds on these prior works, unlike them, it is based on reinforcement learning for Adaptive Exploration, and Adaptive Sampling that leverages clustering to reduce the number of measurements. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement learning for hyper-parameter optimization. There are a growing body of studies on using reinforcement learning to perform various optimizations (Gao et al., 2018; Mirhoseini et al., 2017; Nareyek, 2003; Mao et al., 2016; Xu et al., 2018; Mao et al., 2019) for a variety of objectives including hyper-parameter optimization for neural networks. For instance, DeepArchitect (Negrinho & Gordon, 2017) and NAS (Zoph & Le, 2017) use reinforcement learning to automate the process of designing deep neural network models and their associated parameters. HAQ (Wang et al., 2019) and ReLeQ (Elthakeb et al., 2018) use reinforcement learning to chose levels of quantization for the layers of a given deep neural network. AMC (He et al., 2018) formulates neural network compression as a RL problem. A most recent effort (Paliwal et al., 2020)–which will be published concurrent to ours in ICLR 2020–combined RL with graph neural networks and genetic algorithms to optimize DNN execution. Our work exclusively explores a different problem, that is optimizing compilers using reinforcement learning. ",
+        "bbox": [
+            174,
+            244,
+            825,
+            411
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sampling algorithms for learning. Active learning is a broad field (Settles, 2009; Cohn et al., 1996; Sugiyama, 2006; Cai et al., 2013; Goetz et al., 2018; Wu et al., 2019) that uses a measure of the change in the model to decide which training data elements should be used to update the model. Passive learning (Yu & Kim, 2010; O’Neill et al., 2017) is an alternative view that independent of the model, analyze the distribution of the training data set and selects a subset. The Adaptive Sampling algorithm for CHAMELEON shares similarities with Passive learning but it differs in its context. The sampling is designed to reduce the number of samples (configuration) for hardware measurement from the exploration of the design space whilst performing an optimization to accelerate the process. ",
+        "bbox": [
+            174,
+            428,
+            825,
+            540
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            560,
+            318,
+            577
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We present CHAMELEON to allow optimizing compilers to adapt to unseen design spaces of code schedules to reduce the optimization time. This paper is also an initial effort to bring reinforcement learning to the realm of optimizing compilers for neural networks, and we also develop an Adaptive Sampling with domain-knowledge inspired Sample Synthesis to not only reduce the number of samples required to navigate the design space but also augment its quality in terms of fitness. Experimentation with real-world deep models shows that CHAMELEON not only reduces the time for compilation significantly, but also improves the quality of the code. This encouraging result suggests a significant potential for various learning techniques to optimizing deep learning models. ",
+        "bbox": [
+            174,
+            593,
+            825,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            727,
+            357,
+            741
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank the anonymous reviewers for their insightful comments. We also thank Jinwon Lee and Jangho Kim for the fruitful discussions and feedbacks on the manuscript. This work was in part supported by generous gifts from Qualcomm, Google, Microsoft, and Xilinx as well as the Semiconductor Research Corporation (SRC) contract #2019-SD-2884, National Science Foundation (NSF) awards CNS#1703812, ECCS#1609823, CCF#1553192, Air Force Office of Scientific Research (AFOSR) Young Investigator Program (YIP) award #FA9550-17-1-0274, National Institute of Health (NIH) award #R01EB028350, and Air Force Research Laboratory (AFRL) and Defense Advanced Research Project Agency (DARPA) under agreement number #FA8650-20-2-7009. The U.S. Government is authorized to reproduce and distribute reprints for Governmental purposes notwithstanding any copyright notation thereon. The views and conclusions contained herein are those of the authors and should not be interpreted as necessarily representing the official policies or endorsements, either expressed or implied, of AFRL, DARPA or the U.S. Government. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Mart´ın Abadi, Paul Barham, Jianmin Chen, Zhifeng Chen, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Geoffrey Irving, Michael Isard, et al. TensorFlow: A system for large-scale machine learning. In OSDI, 2016. ",
+        "bbox": [
+            174,
+            125,
+            825,
+            162
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Byung Hoon Ahn, Jinwon Lee, Jamie Menjay Lin, Hsin-Pai Cheng, Jilei Hou, and Hadi Esmaeilzadeh. Ordering chaos: Memory-aware scheduling of irregularly wired neural networks for edge devices. In MLSys, 2020. ",
+        "bbox": [
+            174,
+            172,
+            825,
+            210
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Takuya Akiba, Shuji Suzuki, and Keisuke Fukuda. Extremely large minibatch SGD: training ResNet-50 on ImageNet in 15 minutes. arXiv, 2017. URL https://arxiv.org/pdf/1711.04325.pdf. ",
+        "bbox": [
+            174,
+            220,
+            821,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wenbin Cai, Ya Zhang, and Jun Zhou. Maximizing expected model change for active learning in regression. In ICDM, 2013. ",
+        "bbox": [
+            176,
+            256,
+            823,
+            282
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Pohua P Chang, Scott A Mahlke, and Wen-Mei W Hwu. Using profile information to assist classic code optimizations. Software: Practice and Experience, 1991. ",
+        "bbox": [
+            174,
+            291,
+            823,
+            319
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen and Carlos Guestrin. XGBoost: A scalable tree boosting system. In KDD, 2016. ",
+        "bbox": [
+            173,
+            327,
+            725,
+            340
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Thierry Moreau, Ziheng Jiang, Lianmin Zheng, Eddie Yan, Haichen Shen, Meghan Cowan, Leyuan Wang, Yuwei Hu, Luis Ceze, et al. TVM: An automated end-to-end optimizing compiler for deep learning. In OSDI, 2018a. ",
+        "bbox": [
+            174,
+            349,
+            826,
+            388
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tianqi Chen, Lianmin Zheng, Eddie Yan, Ziheng Jiang, Thierry Moreau, Luis Ceze, Carlos Guestrin, and Arvind Krishnamurthy. Learning to optimize tensor programs. In NeurIPS, 2018b. ",
+        "bbox": [
+            173,
+            398,
+            823,
+            425
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Valeriu Codreanu, Damian Podareanu, and Vikram Saletore. Achieving deep learning training in less than 40 minutes on ImageNet-1K & best accuracy and training time on ImageNet-22K & Places-365 with scale-out Intel\rR Xeon\rR /Xeon PhiTM architectures, 2017. URL https://blog.surf.nl/en/ imagenet-1k-training-on-intel-xeon-phi-in-less-than-40-minutes/. ",
+        "bbox": [
+            174,
+            434,
+            825,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "David A Cohn, Zoubin Ghahramani, and Michael I Jordan. Active learning with statistical models. JAIR, 1996. ",
+        "bbox": [
+            171,
+            494,
+            821,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dorin Comaniciu and Peter Meer. Mean shift: A robust approach toward feature space analysis. TPAMI, 2002. ",
+        "bbox": [
+            173,
+            517,
+            821,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ahmed T Elthakeb, Prannoy Pilligundla, Amir Yazdanbakhsh, Sean Kinzer, and Hadi Esmaeilzadeh. ReLeQ: A reinforcement learning approach for deep quantization of neural networks. arXiv, 2018. URL https: //arxiv.org/pdf/1811.01704.pdf. ",
+        "bbox": [
+            178,
+            540,
+            818,
+            579
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Martin Ester, Hans-Peter Kriegel, Jorg Sander, and Xiaowei Xu. A density-based algorithm for discovering ¨ clusters a density-based algorithm for discovering clusters in large spatial databases with noise. In KDD, 1996. ",
+        "bbox": [
+            173,
+            588,
+            823,
+            627
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matteo Frigo and Steven G Johnson. FFTW: An adaptive software architecture for the FFT. In ICASSP, 1998. ",
+        "bbox": [
+            173,
+            636,
+            821,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuanxiang Gao, Li Chen, and Baochun Li. Post: Device placement with cross-entropy minimization and proximal policy optimization. In NeurIPS, 2018. ",
+        "bbox": [
+            174,
+            659,
+            821,
+            685
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jack Goetz, Ambuj Tewari, and Paul Zimmerman. Active learning for non-parametric regression using purely random trees. In NeurIPS, 2018. ",
+        "bbox": [
+            171,
+            694,
+            823,
+            722
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch,´ Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: Training ImageNet in 1 hour. arXiv, 2017. URL https://arxiv.org/pdf/1706.02677.pdf. ",
+        "bbox": [
+            174,
+            729,
+            823,
+            770
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016. ",
+        "bbox": [
+            171,
+            779,
+            823,
+            804
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yihui He, Ji Lin, Zhijian Liu, Hanrui Wang, Li-Jia Li, and Song Han. AMC: AutoML for model compression and acceleration on mobile devices. In ECCV, 2018. ",
+        "bbox": [
+            169,
+            814,
+            825,
+            840
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew G Howard, Menglong Zhu, Bo Chen, Dmitry Kalenichenko, Weijun Wang, Tobias Weyand, Marco Andreetto, and Hartwig Adam. MobileNets: Efficient convolutional neural networks for mobile vision applications. arXiv, 2017. URL https://arxiv.org/pdf/1704.04861.pdf. ",
+        "bbox": [
+            173,
+            849,
+            821,
+            888
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ken Kennedy and John R Allen. Optimizing compilers for modern architectures: a dependence-based approach. Morgan Kaufmann Publishers Inc., 2001. ",
+        "bbox": [
+            173,
+            897,
+            825,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. ImageNet classification with deep convolutional neural networks. In NIPS, 2012. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            131
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Chris Lattner and Vikram Adve. LLVM: A compilation framework for lifelong program analysis & transformation. In CGO, 2004. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            167
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun. Deep learning hardware: Past, present, and future. In ISSCC, 2019. ",
+        "bbox": [
+            174,
+            175,
+            656,
+            190
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yizhi Liu, Yao Wang, Ruofei Yu, Mu Li, Vin Sharma, and Yida Wang. Optimizing CNN model inference on CPUs. In USENIX ATC, 2019. ",
+        "bbox": [
+            176,
+            199,
+            823,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongzi Mao, Mohammad Alizadeh, Ishai Menache, and Srikanth Kandula. Resource management with deep reinforcement learning. In HotNets, 2016. ",
+        "bbox": [
+            171,
+            234,
+            823,
+            262
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hongzi Mao, Malte Schwarzkopf, Shaileshh Bojja Venkatakrishnan, Zili Meng, and Mohammad Alizadeh. Learning scheduling algorithms for data processing clusters. In SIGCOMM, 2019. ",
+        "bbox": [
+            171,
+            271,
+            821,
+            299
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Peter Mattson, Christine Cheng, Cody Coleman, Greg Diamos, Paulius Micikevicius, David Patterson, Hanlin Tang, Gu-Yeon Wei, Peter Bailis, Victor Bittorf, et al. MLPerf training benchmark. arXiv, 2019. URL https://arxiv.org/pdf/1910.01500.pdf. ",
+        "bbox": [
+            174,
+            306,
+            823,
+            347
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Azalia Mirhoseini, Hieu Pham, Quoc V Le, Benoit Steiner, Rasmus Larsen, Yuefeng Zhou, Naveen Kumar, Mohammad Norouzi, Samy Bengio, and Jeff Dean. Device placement optimization with reinforcement learning. In ICML, 2017. ",
+        "bbox": [
+            171,
+            356,
+            821,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alexander Nareyek. Choosing search heuristics by non-stationary reinforcement learning. In Metaheuristics: Computer Decision-Making. Springer, 2003. ",
+        "bbox": [
+            171,
+            404,
+            823,
+            431
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Renato Negrinho and Geoff Gordon. DeepArchitect: Automatically designing and training deep architectures. arXiv, 2017. URL https://arxiv.org/pdf/1704.08792.pdf. ",
+        "bbox": [
+            169,
+            440,
+            821,
+            468
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diego Novillo. SamplePGO - the power of profile guided optimizations without the usability burden. In LLVM Compiler Infrastructure in HPC, 2014. ",
+        "bbox": [
+            173,
+            477,
+            823,
+            503
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jack O’Neill, Sarah Jane Delany, and Brian MacNamee. Model-free and model-based active learning for regression. In Advances in Computational Intelligence Systems. Springer, 2017. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditya Paliwal, Felix Gimeno, Vinod Nair, Yujia Li, Miles Lubin, Pushmeet Kohli, and Oriol Vinyals. Reinforced genetic algorithm learning for optimizing computation graphs. In ICLR, 2020. URL https: //openreview.net/forum?id $=$ rkxDoJBYPB. ",
+        "bbox": [
+            173,
+            547,
+            821,
+            588
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. PyTorch: An imperative style, high-performance deep learning library. In NeurIPS, 2019. ",
+        "bbox": [
+            173,
+            597,
+            823,
+            636
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nadav Rotem, Jordan Fix, Saleem Abdulrasool, Garret Catron, Summer Deng, Roman Dzhabarov, Nick Gibson, James Hegeman, Meghan Lele, Roman Levenstein, et al. Glow: Graph lowering compiler techniques for neural networks. arXiv, 2018. URL https://arxiv.org/pdf/1805.00907.pdf. ",
+        "bbox": [
+            174,
+            645,
+            823,
+            685
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Eric Schkufza, Rahul Sharma, and Alex Aiken. Stochastic superoptimization. In ASPLOS, 2013. ",
+        "bbox": [
+            173,
+            694,
+            745,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Filip Wolski, Prafulla Dhariwal, Alec Radford, and Oleg Klimov. Proximal policy optimization algorithms. arXiv, 2017. URL https://arxiv.org/pdf/1707.06347.pdf. ",
+        "bbox": [
+            173,
+            717,
+            821,
+            744
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Burr Settles. Active learning literature survey. Technical report, University of Wisconsin-Madison Department of Computer Sciences, 2009. ",
+        "bbox": [
+            173,
+            752,
+            823,
+            780
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. In ICLR, 2015. ",
+        "bbox": [
+            173,
+            789,
+            821,
+            816
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard M Stallman and GCC DeveloperCommunity. Using the GNU compiler collection: a GNU manual for GCC version 4.3.3. CreateSpace, 2009. ",
+        "bbox": [
+            173,
+            824,
+            823,
+            852
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Masashi Sugiyama. Active learning in approximately linear regression based on conditional expectation of generalization error. JMLR, 2006. ",
+        "bbox": [
+            173,
+            861,
+            823,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wei Liu, Yangqing Jia, Pierre Sermanet, Scott Reed, Dragomir Anguelov, Dumitru Erhan, Vincent Vanhoucke, and Andrew Rabinovich. Going deeper with convolutions. In CVPR, 2015. ",
+        "bbox": [
+            173,
+            897,
+            826,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Vasilache, Oleksandr Zinenko, Theodoros Theodoridis, Priya Goyal, Zachary DeVito, William S Moses, Sven Verdoolaege, Andrew Adams, and Albert Cohen. Tensor Comprehensions: Frameworkagnostic high-performance machine learning abstractions. arXiv, 2018. URL https://arxiv.org/ pdf/1802.04730.pdf. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            156
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kuan Wang, Zhijian Liu, Yujun Lin, Ji Lin, and Song Han. HAQ: Hardware-aware automated quantization with mixed precision. In CVPR, 2019. ",
+        "bbox": [
+            173,
+            165,
+            823,
+            191
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "R Clinton Whaley and Jack J Dongarra. Automatically tuned linear algebra software. In SC, 1998. ",
+        "bbox": [
+            173,
+            199,
+            756,
+            214
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Mitchell Wortsman, Ali Farhadi, and Mohammad Rastegari. Discovering neural wirings. In NeurIPS, 2019. ",
+        "bbox": [
+            174,
+            222,
+            807,
+            237
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Dongrui Wu, Chin-Teng Lin, and Jian Huang. Active learning for regression using greedy sampling. Information Sciences, 2019. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            272
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring randomly wired neural networks for image recognition. In ICCV, 2019. ",
+        "bbox": [
+            174,
+            280,
+            821,
+            306
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhongwen Xu, Hado P van Hasselt, and David Silver. Meta-gradient reinforcement learning. In NeurIPS, 2018. ",
+        "bbox": [
+            173,
+            315,
+            823,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Igor Gitman, and Boris Ginsburg. Large batch training of convolutional networks. arXiv, 2017. URL https://arxiv.org/pdf/1708.03888.pdf. ",
+        "bbox": [
+            176,
+            338,
+            823,
+            364
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Zhao Zhang, Cho-Jui Hsieh, James Demmel, and Kurt Keutzer. ImageNet training in minutes. In ICPP, 2018. ",
+        "bbox": [
+            174,
+            373,
+            826,
+            400
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Hwanjo Yu and Sungchul Kim. Passive sampling for regression. In ICDM, 2010. ",
+        "bbox": [
+            174,
+            409,
+            655,
+            422
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. BMVC, 2016. ",
+        "bbox": [
+            174,
+            431,
+            655,
+            445
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Barret Zoph and Quoc V Le. Neural architecture search with reinforcement learning. ICLR, 2017. URL https://openreview.net/forum?id $=$ r1Ue8Hcxg. ",
+        "bbox": [
+            176,
+            454,
+            823,
+            481
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            264,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENTAL SETUP ",
+        "bbox": [
+            176,
+            135,
+            405,
+            152
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 DNN MODELS AND LAYERS ",
+        "bbox": [
+            174,
+            166,
+            416,
+            181
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/1f4b9e5e2139f8aea12a8b1c0cfa48d7fa165cc7ca2b1a98d173ffb34c503183.jpg",
+        "table_caption": [
+            "Table 4: Details of the DNN models used in evaluating CHAMELEON. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>NETWORK</td><td>DATASET</td><td>NUMBER OF TASKS</td></tr><tr><td>AlexNet</td><td>ImageNet</td><td>5</td></tr><tr><td>VGG-16</td><td>ImageNet</td><td>9</td></tr><tr><td>ResNet-18</td><td>ImageNet</td><td>12</td></tr></table>",
+        "bbox": [
+            344,
+            229,
+            651,
+            296
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/51615402d54a7b4125395cfc793ce077919a4bdac41bb9811ad6e61dc1f91fdb.jpg",
+        "table_caption": [
+            "Table 5: Details of the layers used in evaluating CHAMELEON. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>NAME</td><td>MODEL</td><td>LAYER TYPE</td><td>TASK INDEX</td></tr><tr><td>L1</td><td>AlexNet</td><td>convolution</td><td>1</td></tr><tr><td>L2</td><td>AlexNet</td><td>convolution</td><td>4</td></tr><tr><td>L3</td><td>VGG-16</td><td>convolution</td><td>1</td></tr><tr><td>L4</td><td>VGG-16</td><td>convolution</td><td>2</td></tr><tr><td>L5</td><td>VGG-16</td><td>convolution</td><td>4</td></tr><tr><td>L6</td><td>ResNet-18</td><td>convolution</td><td>6</td></tr><tr><td>L7</td><td>ResNet-18</td><td>convolution</td><td>9</td></tr><tr><td>L8</td><td>ResNet-18</td><td>convolution</td><td>11</td></tr></table>",
+        "bbox": [
+            326,
+            363,
+            669,
+            492
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 HARDWARE SPECIFICATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            411,
+            537
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "table",
+        "img_path": "images/39f0387a3536ecfabd68083e103df74299ebe51fca4f6e995f879cab9e1e0c17.jpg",
+        "table_caption": [
+            "Table 6: Details of the hardware used for evaluation of CHAMELEON. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>SPECIFICATIONS</td><td>DETAILS</td></tr><tr><td>GPU</td><td>Titan Xp</td></tr><tr><td>Host CPU</td><td>3.4G Hz Intel Core i7</td></tr><tr><td>Main Memory</td><td>32GB 2400 MHz DDR3</td></tr></table>",
+        "bbox": [
+            354,
+            583,
+            643,
+            650
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 HYPER-PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            104,
+            367,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/eab548784d37517f4ceb800bdbdcb7b6747845330e0f86233dcd272f731a93cf.jpg",
+        "table_caption": [
+            "Table 7: Hyper-parameters uses in CHAMELEON. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>HYPERPARAMETER</td><td>VALUE</td><td>DESCRIPTION</td></tr><tr><td>iterationopt</td><td>16</td><td>number of iterations for optimization process (equivalent to 1Ooo hardware measurements)</td></tr><tr><td>modeGBT bGBT</td><td>xgb-reg</td><td>type of loss used for cost model</td></tr><tr><td></td><td>64</td><td>maximum batch size of planning in GBT(Chen &amp; Guestrin,2016) cost model per iteration of optimization process</td></tr><tr><td>episoderl</td><td>128</td><td>number of episodes for reinforcement learning</td></tr><tr><td>steprl</td><td>500</td><td>maximum steps of one reinforcement learning episode</td></tr><tr><td>thresholdmeta</td><td>2.5</td><td>threshold used for meta-search in sampling</td></tr><tr><td></td><td></td><td></td></tr></table>",
+        "bbox": [
+            191,
+            165,
+            807,
+            296
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/b4cb30e55c7f5113d4da6353493ce0bd64e828363fb677a7294e655ec60e2b5c.jpg",
+        "table_caption": [
+            "Table 8: Hyper-parameters uses in AutoTVM (Chen et al., 2018b). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>HYPERPARAMETER</td><td>VALUE</td><td>DESCRIPTION</td></tr><tr><td>£(bGBT)</td><td>1000</td><td>totalnumber of hardwaremeasurements</td></tr><tr><td>modeGBT</td><td>xgb-reg</td><td>type of loss used for cost model</td></tr><tr><td>bGBT</td><td>64</td><td>batch size of planning in GBT(Chen&amp; Guestrin,2016)</td></tr><tr><td>nsa</td><td>128</td><td>number of Markov chains in parallel simulated annealing</td></tr><tr><td>stepsa</td><td>500</td><td>maximum steps of one simulated annealing run</td></tr></table>",
+        "bbox": [
+            218,
+            362,
+            779,
+            454
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/e887780cd91b6b8d0629642ce2ecdde3521610a9257416b939239f4a68ca4af4.jpg",
+        "table_caption": [
+            "Table 9: Hyper-parameters used in CHAMELEON’s PPO (Schulman et al., 2017) search agent. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>HYPERPARAMETER</td><td>VALUE</td></tr><tr><td>Adam Step Size Discount Factor</td><td>1×10-3</td></tr><tr><td>GAE Parameter</td><td>0.9</td></tr><tr><td>Number of Epochs</td><td>0.99</td></tr><tr><td>Clipping Parameter</td><td>3</td></tr><tr><td>Value Coefficient</td><td>0.3</td></tr><tr><td></td><td>1.0</td></tr><tr><td>Entropy Coefficient</td><td>0.1</td></tr></table>",
+        "bbox": [
+            388,
+            520,
+            609,
+            638
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "B ADDITIONAL EXPERIMENTAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            537,
+            118
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "B.1 OPTIMIZATION TIME BREAKDOWN FOR DNN MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            133,
+            601,
+            148
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/026a53d0d37fc394dbde9ee260ed92631908ad47f92de723d2f9d7a13438b6e1.jpg",
+        "image_caption": [
+            "Figure 11: AutoTVM optimization time for AlexNet (Krizhevsky et al., 2012) and VGG-16 (Simonyan & Zisserman, 2015), and ResNet-18 (He et al., 2016) on Titan Xp. Numbers in bars denote fraction of time for measurements. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            165,
+            818,
+            305
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c8b2503e8f20893f004a618595f804ee4202bdce892dd2dd37cf5019a6c7a97.jpg",
+        "image_caption": [
+            "Figure 12: Layer evaluations for AlexNet (Krizhevsky et al., 2012). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            468,
+            812,
+            655
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/01cae0b30b91a657d3523b35270fbc77354a18f41266d34fb3123c16b6bd7b20.jpg",
+        "image_caption": [
+            "Figure 13: Layer evaluations for VGG-16 (Simonyan & Zisserman, 2015). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            99,
+            813,
+            369
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d074821723c328e9d090e41a9d4a947aea4d674ac66384eb9bb3c3baedf687b.jpg",
+        "image_caption": [
+            "Figure 14: Layer evaluations for ResNet-18 (He et al., 2016). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            476,
+            813,
+            828
+        ],
+        "page_idx": 16
+    }
+]