Add files using upload-large-folder tool

parse/train/B1eXygBFPH/B1eXygBFPH.md

@@ -0,0 +1,312 @@
+# ATTACKING GRAPH CONVOLUTIONAL NETWORKS VIA REWIRING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Graph Neural Networks (GNNs) have boosted the performance of many graph related tasks such as node classification and graph classification. Recent researches show that graph neural networks are vulnerable to adversarial attacks, which deliberately add carefully created unnoticeable perturbation to the graph structure. The perturbation is usually created by adding/deleting a few edges, which might be noticeable even when the number of edges modified is small. In this paper, we propose a graph rewiring operation which affects the graph in a less noticeable way compared to existing operators. We then use reinforcement learning to learn the attack strategy based on the proposed rewiring operation. Experiments on real world graphs demonstrate the effectiveness of the proposed framework. To understand the proposed framework, we further analyze how its generated perturbation to the graph structure affects the output of the target model and the advantages of the rewiring operation.
+
+# 1 INTRODUCTION
+
+Graph structured data are ubiquitous in many real world applications. Various data from different domains, such as social networks, molecular graphs and transportation networks can all be modeled as graphs. Recently, increasing effort has been devoted towards developing deep neural networks on graph structured data. This stream of works, which is known as Graph Neural Networks (GNN) has shown to enhance the performance in many graph related tasks such as node classification (Kipf & Welling, 2016; Hamilton et al., 2017) and graph classification (Bruna et al., 2013; Defferrard et al., 2016; Ying et al., 2018; Zhang et al., 2018).
+
+Recent researches have shown that deep neural networks are highly vulnerable to adversarial attacks (Szegedy et al., 2013; Goodfellow et al., 2014; Kurakin et al., 2016; Carlini & Wagner, 2017). In computer vision, performing an adversarial attack is to add deliberately created, but unnoticeable, perturbation to a given image such that the deep model misclassifies the perturbed image. Unlike image data, which can be represented in the continuous space, graph structured data is discrete. Few efforts have been made to investigate the robustness of graph neural networks against adversarial attacks. Only recently, such researches about adversarial attacks on graph structured data started to emerge. A greedy algorithm is proposed to attack the semi-supervised node classification task (Zugner et al., 2018). The method deliberately tries to modify the graph structure and node ¨ features such that the label of a targeted node can be changed. A reinforcement learning based algorithm is proposed to attack both node classification and graph classification task by only modifying the graph structure(Dai et al., 2018). A meta-learning based attack method is designed to impair the overall performance of the node classification task(Zugner & G ¨ unnemann, 2019). For the majority ¨ of existing works, the graph structure is modified by adding or deleting edges.
+
+To ensure that the difference between the attacked graph and the original graph is “unnoticeable”, the number of actions (adding/deleting edges) that can be taken by the attacking algorithms is usually constrained by a budget. However, even when this budget is small, adding or deleting edges can still make “noticeable” changes to the graph structure (Miller et al., 2019). For example, it is evident that many important graph properties are based on eigenvalues and eigenvectors of the Laplacian matrix of the graph (Chan & Akoglu, 2016); while adding or deleting an edge can make remarkable changes on the eigenvalues/eigenvectors of the graph Laplacian (Ghosh & Boyd, 2006). Thus, in this work, we propose a new operation based on graph rewiring. A single rewiring operation involves three nodes $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ , where we remove the existing edge between $v _ { f i r }$ and $v _ { s e c }$ and add edge between $v _ { f i r }$ and $v _ { t h i }$ . Note that $v _ { t h i }$ is constraint to be the 2-hop neighbor of $v _ { f i r }$ in our setting. It is obvious that the proposed rewiring operation preserves some basic properties of the graph such as number of nodes and edges, total degrees of the graph and etc, while operations like adding and deleting edges cannot. Furthermore, the proposed rewiring operation affects some of the important measures based on graph Laplacian such as algebraic connectivity in a smaller way than adding/deleting edges, which is theoretically demonstrated in Section 4.1. In addition, the rewiring operation is a more natural way to modify the graph. For example, in biology, the evolution of DNA and amino acid sequences can lead to pervasive rewiring of protein–protein interactions (Zitnik et al., 2019).
+
+In this paper, we aim to construct adversarial examples by performing rewiring operations for the task of graph classification. More specifically, we treat the process of applying a series of rewiring operations to a given graph as a discrete Markov decision process (MDP) and use reinforcement learning to learn how to make these decisions. We demonstrate the effectiveness of the proposed algorithm on real-world graphs. Then we further analyze how the adversarial changes in the graph structure affect both the graph embedding learned by the graph neural network model and the output label and illustrate the advantages of the rewiring operation.
+
+# 2 BACKGROUND
+
+In this section, we introduce notations and the target graph convolutional model we seek to attack. We denote a graph as $G = \{ \nu , \mathcal { E } \}$ , where $\mathcal { V } = \{ v _ { 1 } , \ldots , v _ { | \mathcal { V } | } \}$ and $\mathcal { E } = \{ e _ { 1 } , \ldots , e _ { | \mathcal { E } | } \}$ are the sets of nodes and edges, respectively. The edges describe the relations between nodes, which can be described by an adjacency matrix $\mathbf { A } \in \{ \bar { 0 } , 1 \} ^ { | \mathcal { V } | \times | \mathcal { V } | }$ . $\mathbf { A } _ { i j } = 1$ means $v _ { i }$ and $v _ { j }$ are connected, 0 otherwise. Each node in the graph has some features that are associated with it. These features are represented as a matrix $\mathbf { X } \in \mathbb { R } ^ { | \bar { \nu } | \times d }$ , where the $i$ -th row of $\mathbf { X }$ denotes the node features of node $v _ { i }$ and $d$ is the dimension of features. Thus, an attributed graph can be represented as $G = \{ \mathbf { A } , \mathbf { X } \}$ .
+
+# 2.1 GRAPH CLASSIFICATION
+
+In the setting of graph classification, we are given a set of graphs $\mathcal { G } = \{ G _ { i } \}$ . Each of these graphs $G _ { i }$ is associated with a label $y _ { i }$ . The task is to build a good classifier using the given set of graphs such that it can make correct predictions when new unseen graphs are fed into it. A graph classifier parameterized by $\theta$ can be represented as $f ( G | \theta ) = y ^ { o }$ , where $y ^ { o }$ denotes the label of a graph $G \in { \mathcal { G } }$ predicted by the classifier. The parameters $\theta$ in the classifier $f ( \cdot | \theta )$ can be learned by solving the following optimization problem $\begin{array} { r } { \operatorname* { m i n } _ { \theta } \sum _ { i } L ( f ( G _ { i } | \theta ) , y _ { i } ) } \end{array}$ , where $L ( \cdot , \cdot )$ is used to measure the difference between the predicted and ground truth labels. Cross entropy is a commonly adopted measurement for $L ( \cdot , \cdot )$ .
+
+# 2.2 GRAPH CONVOLUTION NETWORKS
+
+Recently, Graph Neural Networks have been shown to be effective in graph representation learning. These models usually learn node representations by iteratively aggregating, transforming and propagating node information. In this work, we adopt the graph convolutional networks (GCN) (Kipf & Welling, 2016). A graph convolutional layer in the GCN framework can be represented as
+
+$$
+\mathbf { F } ^ { j } = R e L U ( \mathbf { D } ^ { - \frac { 1 } { 2 } } \mathbf { A } \mathbf { D } ^ { - \frac { 1 } { 2 } } \mathbf { F } ^ { j - 1 } \mathbf { W } ^ { j } )
+$$
+
+where $\mathbf { F } ^ { j } \in \mathbb { R } ^ { N \times d _ { j } }$ is the output of the $j$ -th layer and $\mathbf { W } ^ { j }$ represents the parameters of this layer. A GCN model usually consists of $J$ graph convolutional layers, with $\mathbf { F } ^ { 0 } \equiv \mathbf { X }$ . The output of the GCN model is $\mathbf { F } ^ { J }$ , which is denote as $\mathbf { F }$ for convenience. To obtain a graph level embedding $\mathbf { u } _ { G }$ for graph $G$ to perform graph classification, we apply a global pooling over the node embeddings.
+
+$$
+\mathbf { u } _ { G } = p o o l ( \mathbf { F } )
+$$
+
+Different global pooling functions can be used, and we adopt the max pooling in this work. A multilayer perceptron (MLP) and softmax layer are then sequentially applied on the graph embedding to predict the label of the graph
+
+$$
+y ^ { o } = \mathrm { a r g m a x } ~ s o f t m a x ( M L P ( \mathbf { u } _ { G } | \mathbf { W } _ { M L P } ) )
+$$
+
+where $M L P ( \cdot | \mathbf { W } _ { M L P } )$ denotes the multilayer perceptron with parameters as ${ \bf W } _ { M L P }$ . A GCNbased classifier for graph classification can be described using eq. equation 1, equation 2 and equation 3 as introduced above. For simplicity, we summarize it as $y ^ { \bar { o } } = \bar { f } _ { G C N } ( G | \bar { \theta _ { G C N } } )$ , where $\theta _ { G C N }$ includes all the parameters in the model.
+
+# 3 PROBLEM FORMULATION
+
+In this work, we aim to build an attacker $\tau$ that takes a graph as input and modify the structure of the graph to fool a GCN classifier. Modifying a graph structure is equivalent to modify its adjacency matrix. The function of the attacker can be represented as $\tilde { G } = \bar { \mathcal { T } } ( G ) = \{ \mathcal { T } ( \mathbf { A } ) , \dot { \mathbf { X } } \} = \{ \tilde { \mathbf { A } } , \mathbf { X } \}$ . Given a classifier $f ( \cdot )$ , the goal of the attacker is to modify the graph structure so that the classifier outputs a different label from what it originally predicted. Note here, we neglect the $\theta$ inside $f ( \cdot )$ , as the classifier is already trained and fixed. Mathematically, the goal of the attacker can be represented as: $f ( { \mathcal { T } } ( G ) ) \neq f ( G )$ .
+
+As described above, the attacker $\tau$ is specifically designed for a given classifier $f ( \cdot )$ . To reflect this in the notation, we now denote the attacker for the classifier $f ( \cdot )$ as $\mathcal { T } _ { f }$ . In our work, the attacker $\mathcal { T } _ { f }$ has limited knowledge of the classifier. The only information the attacker can get from the classifier is the label of (modified) graphs. In other words, the classifier $f ( \cdot )$ is treated as a black-box model for the attacker $\mathcal { T } _ { f }$ .
+
+An important constraint to the attacker $\mathcal { T } _ { f }$ is that it is only allowed to make “unnoticeble” changes to the graph structure. To account for this, we propose the rewiring operation, which is supposed to make more subtle changes than adding or deleting edges. We will show that the rewiring operation can better preserve a lot of important properties of the graph compared to adding or deleting edges in Section 4.1. We also empirically compare the rewiring operation with the deleting/adding edges in Appendix C. The definition of the proposed rewiring is given below:
+
+Definition 1. $A$ rewiring operation a involves three nodes and it can be denoted as ${ \bf a } \_ =$ $\{ v _ { f i r } , v _ { s e c } , v _ { t h i } \}$ , where $\breve { v } _ { s e c } \in N ^ { 1 } ( v _ { f i r } )$ and $v _ { t h i } \in N ^ { 2 } ( v _ { f i r } ) / N ^ { 1 } ( v _ { f i r } )$ . $N ^ { k } ( v _ { f i r } )$ denotes the $k$ -th hop neighbors of $v _ { f i r }$ and the sign / stands for exclusion. The rewiring operation deletes the existing edge between nodes $v _ { f i r }$ and $v _ { s e c } ,$ , while adding an edge to connect nodes $v _ { f i r }$ and $v _ { t h i }$ .
+
+The attacker $\mathcal { T } _ { f }$ is given a budget of $K$ proposed rewiring operations to modify the graph structure. A straightforward way to set $K$ is choosing a small fix number. However, it is likely that graphs in a given data set have various graph sizes. The same number of rewiring operations can affect the graphs of different size in various magnitude. Hence, a more suitable way is to allow flexible number of rewiring operations according to the graph size. Thus, we propose to use $K = p \cdot | { \mathcal { E } } |$ for a given graph $G$ , where $p \in ( 0 , 1 )$ is a ratio.
+
+The process of the attacker on a graph $G$ can be now denoted as $\mathcal { T } _ { f } ( G )  ( a _ { 1 } , a _ { 2 } , \dotsc , a _ { M } ) [ G ] .$ , where the right hand part means to sequentially apply the rewiring operations $a _ { 1 } , \dots , a _ { M }$ to the graph $G$ , and $M$ is the number of rewiring operations taken with $M \leq K$ .
+
+# 4 REWIRING-BASED ATTACK TO GRAPH CONVOLUTIONAL NETWORKS
+
+Next, we first discuss the properties of the proposed rewiring operation to show its advantages. We then introduce the proposed attacking framework ReWatt based on reinforcement learning and rewiring.
+
+# 4.1 PROPERTIES OF THE PROPOSED REWIRING OPERATION
+
+The proposed rewiring operation has several advantages compared to simply adding or deleting edges. More empirical discussions can be found in Appendix C. One obvious advantage of the proposed rewiring operation is that it does not change the number of nodes, the number of edges and the total degree of a graph. However, operations like “adding” or “deleting” edges may change those properties.
+
+Many important graph properties are based on the eigenvalues of the Laplacian matrix of a graph (Chan & Akoglu, 2016) such as Algebraic Connectivity Fiedler (1973) and Effective Graph
+
+Resistance Ellens et al. (2011). A detailed description of Algebraic Connectivity and Effective Graph Resistance are given in Appendix A. Next, we demonstrate that the proposed rewiring operation is likely to make smaller changes to eigenvalues, which result in unnoticeable changes under graph Laplacian based measures. For a graph $G$ with $\mathbf { A }$ as its adjacency matrix, its Laplacian matrix $\mathbf { L }$ is defined as $\mathbf { L } = \mathbf { D } - \mathbf { A }$ , where $\mathbf { D }$ is the diagonal degree matrix (Mohar et al., 1991). Let $\lambda _ { 1 } , \ldots , \lambda _ { | \nu | }$ denote the eigenvalues of the Laplacian matrix arranged in the increasing order with $\mathbf { x } _ { 1 } , \ldots , \mathbf { x } _ { | \mathcal { V } | }$ being the corresponding eigenvectors. We show how a single proposed rewiring operation affects the eigenvalues. Our analysis is based on the following lemma:
+
+Lemma 1. (Stewart, 1990) Let $\left( \alpha _ { i } , \mathbf { h } _ { i } \right)$ be the eigen-pairs of a symmetric matrix $\mathbf { M } \in \mathbb { R } ^ { N \times N }$ Given a perturbation $\Delta \mathbf { M }$ to matrix M, its eigenvalues can be updated by $\Delta \alpha _ { i } = \mathbf { h } _ { i } ^ { T } \Delta \mathbf { M } \mathbf { h } _ { i }$ .
+
+The proof can be found in (Stewart, 1990). Using this lemma, we have the following corollary Corollary 1. For a given graph $G$ with Laplacian matrix $\mathbf { L }$ , one proposed rewiring operation $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ affects the eigen-value $\lambda _ { i }$ by $\Delta \lambda _ { i } ,$ , for $i = 1 , \ldots , | \nu |$ , where
+
+$$
+\Delta { \lambda } _ { i } = ( 2 { \bf { x } } _ { i } [ f i r ] - { \bf { x } } _ { i } [ t h i ] - { \bf { x } } _ { i } [ s e c ] ) ( { \bf { x } } _ { i } [ s e c ] - { \bf { x } } _ { i } [ t h i ] )
+$$
+
+where $\mathbf { x } _ { i } [ i n d e x ]$ denotes the index-th value of the eigenvector $\mathbf { x } _ { i }$
+
+The proof can be found in Appendix B.
+
+Furthermore, each eigenvalue $\lambda _ { i }$ of the Laplacian matrix measures the “smoothness” of its corresponding eigenvector $\mathbf { x } _ { i }$ (Shuman et al., 2012; Sandryhaila & Moura, 2014). The “smoothness” of an eigenvector measures how different its elements are from their neighboring nodes. Thus, the first few eigenvectors with relatively small eigenvalues are rather “smooth”. Note that in the proposed rewiring operation, $v _ { s e c }$ is the direct neighbor of $v _ { f i r }$ and $v _ { t h i }$ is the 2-hop neighbor of $v _ { f i r }$ . Thus, the difference ${ \bf x } _ { i } [ f i r ] - { \bf x } _ { i } [ t h i ]$ is expected to be smaller than the difference ${ \bf x } _ { i } [ f i r ] - { \bf x } _ { i } [ c \dot { a } n ]$ , where $\mathbf { x } _ { i } [ c a n ]$ can be any other node that is further away. This means that the proposed rewiring operation (to 2-hop neighbors) is likely to make smaller changes to the first few eigenvalues than rewiring to any further away nodes or adding an edge between two nodes that are far away from each other.
+
+# 4.2 GRAPH ADVERSARIAL ATTACK WITH REINFORCEMENT LEARNING
+
+Given a graph $G$ , the process of the attacker $\tau$ is a general decision making process $M \ =$ $( \boldsymbol { S } , \mathcal { A } , \boldsymbol { P } , \boldsymbol { R } )$ , where $\mathcal { A } \stackrel { \bf { \bar { \Delta } } } { = } \{ a _ { t } \}$ is the set of actions, which consists of all valid rewiring operations, ${ \cal { S } } = \{ s _ { t } \}$ is the set of states that consists of all possible intermediate and final graphs after rewiring, $P$ is the transition dynamics that describes how a rewiring action $a _ { t }$ changes the graph structure $p ( s _ { t + 1 } | , s _ { t } , \ldots , s _ { 1 } , \bar { a _ { t } } )$ . $R$ is the reward function, which gives the reward for the action taken at a given state. Thus, the procedure of attacking a graph can be described by a trajectory $( s _ { 1 } , a _ { 1 } , r _ { 1 } , \ldots , s _ { M } , a _ { M } , r _ { M } )$ , where $s _ { 1 } ~ = ~ G$ . The key point for the attacker is to learn how to make the decision of picking a suitable rewiring action when at the state $s _ { t }$ . This can be done by learning a policy network to get the probability $p ( a _ { t } | s _ { t } , \ldots , s _ { 1 } )$ and sample the rewiring operation correspondingly. Modelling in this way, the decision making at a state $s _ { t }$ is dependant on all its previous states, which could be difficult to model due to the long-term dependency. It is easy to notice that the intermediate states $s _ { t }$ are all predicted to have the same label as the original graph. Thus, we can treat each of the states as a brand new graph to be attacked regardless of what leads to it. That is to say, the decision making at the state $s _ { t }$ can be solely dependant on the current state, $p ( a _ { t } | s _ { t } , \ldots , s _ { 1 } ) = p ( a _ { t } | s _ { t } )$ . Thus, we model the process of attack as a Markov Decision Process (MDP) Sutton & Barto (2018). Hence, we adopt reinforcement learning to learn how to make effective decisions. We name the proposed framework as ReWatt. The key elements of the environment for the reinforcement learning are defined as follows:
+
+State Space The state space of the environment consists of all the intermediate graphs generated after the possible rewiring operations.
+
+Action Space The action space consists of the valid rewiring operations as defined in Definition 1.
+
+State Transition Dynamics Given an action (rewiring operation) $a _ { t } = \{ v _ { f i r } , v _ { s e c } , v _ { t h i } \}$ at state $s _ { t }$ The next state $s _ { t + 1 }$ is achieved by deleting the edge between $v _ { f i r }$ and $v _ { s e c }$ in the current state $s _ { t }$ and adding an edge to connect $v _ { f i r }$ with $v _ { t h i }$ .
+
+Reward Design The main goal of the attacker is to make the classifier $f ( \cdot )$ predict a different label than originally predicted. We also encourage the attacker to take as few actions as possible so that the modification to the graph structure is minimal. Thus, we assign a positive reward when the attack is successful and assign a negative reward for each action step taken. The reward $R ( s _ { t } , a _ { t } )$ is given as
+
+$$
+R ( s _ { t } , a _ { t } ) = { \left\{ \begin{array} { l l } { ~ 1 ~ } & { { \mathrm { i f } } ~ f ( s _ { t } ) \neq f ( s _ { 1 } ) ; } \\ { n _ { r } ~ } & { { \mathrm { i f } } ~ f ( s _ { t } ) = f ( s _ { 1 } ) . } \end{array} \right. }
+$$
+
+where $n _ { r }$ is the negative reward to penalize each step taken. Similar to how we set a flexible rewiring budget $K$ , here we propose to use $\begin{array} { r } { \dot { n } _ { r } = - \frac { 1 } { K } = - \frac { 1 } { p \cdot | \mathcal { E } | } } \end{array}$ − 1p·|E| , which depends on the size of the graph.
+
+Termination The attack process will stop either when the number of actions reaches the budget $K$ or the attacker successfully “changed” the label of the slightly modified graph.
+
+# 4.3 POLICY NETWORK
+
+In this subsection, we introduce the policy network to learn the policy $p ( a _ { t } | s _ { t } )$ on top of the graph representations learned by GCN. However, this GCN is different from the target classifier one, since it has 2 convectional layers. To choose a valid proposed rewiring action, we decompose the rewiring action to 3 steps: 1) choosing an edge $e _ { t } = ( v _ { e _ { 1 } } , v _ { e _ { 2 } } )$ from the set of edges of the intermediate graph $s _ { t } ; 2 )$ determining $v _ { e _ { t 1 } }$ or $v _ { e _ { t 2 } }$ to be ${ \boldsymbol { v } } _ { f i r _ { t } }$ and the other to be $v _ { s e c _ { t } }$ ; and 3) choosing the third node $v _ { t h i _ { t } }$ from $N _ { s _ { t } } ^ { 2 } ( v _ { f i r _ { t } } ) / N _ { s _ { t } } ^ { 1 } ( v _ { f i r _ { t } } )$ . Correspondingly, we decompose $p ( a _ { t } | s _ { t } )$ as follows
+
+$$
+p ( a _ { t } | s _ { t } ) = p _ { e d g e } ( e _ { t } | s _ { t } ) \cdot p _ { f i r } ( v _ { f i r _ { t } } | e _ { t } , s _ { t } ) \cdot p _ { t h i } ( v _ { t h i _ { t } } | v _ { f i r _ { t } } , e _ { t } , s _ { t } )
+$$
+
+We design three policy networks based on GCN to estimate the three distributions in the right hand of the equation equation 5, which will be introduced next. To select an edge from the edge set $\mathcal { E } _ { s _ { t } }$ , we generate the edge representation from the node representations $\mathbf { F } _ { s _ { t } } \in \mathbb { R } ^ { | \mathcal { V } _ { s _ { t } } | \times d _ { F } }$ learned by GCN. For an edge $\boldsymbol { e } ~ = ~ \left( v _ { e _ { 1 } } , v _ { e _ { 2 } } \right)$ , the edge representation can be represented as $\textbf { e } = \ c o n c a t ( \mathbf { u } _ { s _ { t } } , h ( \mathbf { F } _ { s _ { t } } [ e _ { 1 } , : ] , \mathbf { F } _ { s _ { t } } [ e _ { 2 } , : ] ) )$ , where $\mathbf { u } _ { s _ { t } }$ is the graph representation of the state $s _ { t }$ , $h ( \cdot , \cdot )$ is a function to combine the two node representations and $c o n c a t ( \cdot , \cdot )$ denotes the concatenation operation. We include $\mathbf { u } _ { s t }$ in the representation of the edge to incorporate the graph information when making the decision. The representation of all the edges in $\mathcal { E } _ { s _ { t } }$ can be represented as a matrix $\mathbf { E } _ { s _ { t } } \in \mathbb { R } ^ { | \mathcal { E } _ { s _ { t } } | \times 2 d _ { F } }$ , where each row represents an edge. The probability distribution over all the edges can be represented as
+
+$$
+p _ { e d g e } ( \cdot | s _ { t } ) = s o f t m a x ( M L P ( \mathbf { E } _ { s _ { t } } | \theta _ { e d g e } ) ) ,
+$$
+
+where we use $M L P ( \cdot | \theta _ { e d g e } )$ to denote a Multilayer Perceptron that maps $\mathbf { E } _ { s _ { t } } \in \mathbb { R } ^ { | \mathcal { E } _ { s _ { t } } | \times 2 d _ { F } }$ to a vector in $\mathbb { R } ^ { | \mathcal { E } _ { s _ { t } } | }$ , which, after going through the softmax layer, represents the probability of choosing each edge. Let $e _ { t } = ( v _ { e _ { t 1 } } , v _ { e _ { t 2 } } )$ denote the edge sampled according to eq. equation 6. To decide which node is going to be the first node, we estimate the probability distribution over these two nodes as
+
+$$
+p _ { f i r } ( \cdot | e _ { t } , s _ { t } ) = s o f t m a x ( M L P ( [ \mathbf { v } _ { e _ { t 1 } } , \mathbf { v } _ { e _ { t 2 } } ] ^ { T } | \theta _ { f i r } ) )
+$$
+
+where $\mathbf { v } _ { e _ { t _ { i } } } = c o n c a t ( \mathbf { e } _ { t } , \mathbf { F } _ { s _ { t } } [ e _ { t { i } } , : ] ) \in \mathbb { R } ^ { 3 d _ { F } }$ for $i = 1 , 2$ . The first node can be sampled from the two nodes $v _ { e _ { t 1 } } , v _ { e _ { t 2 } }$ according to eq. equation 7. We then proceed to estimate the probability distribution $p ( \cdot | v _ { f i r _ { t } } , e _ { t } , s _ { t } )$ . For any node $v _ { c } ~ \in ~ { \cal N } ^ { 2 } ( v _ { f i r _ { t } } ) / { \cal N } ^ { 1 } ( v _ { f i r _ { t } } )$ , we use $\begin{array} { r l } { \hat { \mathbf { v } } _ { c } } & { { } = } \end{array}$ $c o n c a t ( \mathbf { v } _ { e _ { t 1 } } , \mathbf { F } _ { s _ { t } } [ c , : ] )$ to represent it. The representations for all the nodes in $N ^ { 2 } \dot { ( } v _ { f i r _ { t } } ) / N ^ { 1 } ( v _ { f i r _ { t } } )$ can be represented by a matrix $\hat { \bf V } _ { s _ { t } } \in \mathbb { R } ^ { | N ^ { 2 } ( v _ { f i r _ { t } } ) / N ^ { 1 } ( v _ { f i r _ { t } } ) | \times 4 d _ { F } }$ with each row representing a node. The probability distribution of choosing the third node over all the candidate nodes can be modeled as:
+
+$$
+p _ { t h i } ( \cdot | v _ { f i r _ { t } } , e _ { t } , s _ { t } ) = s o f t m a x ( M L P ( \hat { \mathbf { V } } _ { s _ { t } } | \theta _ { t h i } ) )
+$$
+
+The third node $v _ { t h i _ { t } }$ can be sampled from the set of candidate nodes $N ^ { 2 } ( v _ { f i r _ { t } } ) / N ^ { 1 } ( v _ { f i r _ { t } } )$ according to the probability distribution in eq equation 8. An action $a _ { t }$ can be generated by sequentially estimating and sampling from the probability distributions in eq. equation 6, equation 7 and equation 8.
+
+# 4.4 PROPOSED FRAMEWORK - REWATT
+
+With the rewiring and the policy network defined above, our overall framework can be summarized as follows. With State $s _ { t }$ , the Attacker uses GCN to learn node and edge embeddings, which are used as input to Policy Networks to make decision about the next action. Once the new action is sampled from the policy network, rewiring is performed on $s _ { t }$ and we arrive in the new state $s _ { t + 1 }$ . We query the black-box classifier to get the prediction $f ( S _ { t + 1 } )$ , which is compared with $f ( s _ { 1 } )$ to get reward. Policy gradient (Sutton & Barto, 2018) is adopted to learn the policies by maximizing the rewards.
+
+# 5 EXPERIMENT
+
+In this section, we conduct experiments to evaluate the performance of the proposed framework ReWatt. We also carry out a study to analyze how the trained attacker works. Some empirical investigation on the advancements of the rewiring operation can be found in Appendix C.
+
+# 5.1 ATTACK PERFORMANCE
+
+To demonstrate the effectiveness of ReWatt, we conduct experiments on three widely used social network data sets (Kersting et al., 2016) for graph classification, i.e., REDDIT-MULTI-12K, REDDITMULTI-5K and IMDB-MULTI (Yanardag & Vishwanathan, 2015). The statistics can be found in Appendix D. Note that the re-wiring operation (as well as the other operations) may lead to abnormal structure of some kinds of graphs, which can make the graphs invalid, especially for chemical molecules. So in this paper, We avoid chemical related datasets but only use social networks datasets. In the social domain, if the changes are subtle, it is most likely that we will not we will not introduce abnormal structures. Meanwhile, it is straightforward to extend our framework to datsets from the other domains if we have expertise in them. For example, if we know what structures are abnormal, we can use such knowledge to constraint the the state space of the RL framework. We leave it as one future work.
+
+In this work, the classifier we target to attack is the GCN-based classifier as introduced in Section 2. We set the number of layers to 3. We need to train the classifier using a fraction of the data and then treat the classifier as a black box to be attacked. We then use part of the remaining data to train the attacker and use the rest of the data to test the performance of the attacker. Thus, for each data set, we split it into three parts with the ratio of $a \% : b \% : c \%$ , where $a \%$ of the data set is used to train the classifier, $b \%$ of the data set is used to train the attacker and the remaining $c \%$ of the data set is used to test the performance of the attacker. For the REDDIT-MULTI-12K and REDDIT-MULTI5K data sets, we set $a = 9 0$ , $b = 8$ and $c = 2$ . As the size of the IMDB-MULTI data set is quite small, to have enough data for testing, we set $a = 5 0$ , $b = 3 0$ and $c = 2 0$ .
+
+We compare the attacking performance of the proposed framework with the RL-S2V proposed in (Dai et al., 2018), random selection method and some variants of our proposed framework. We briefly describe these baselines: 1) RL-S2V is a reinforcement learning based attack framework (Dai et al., 2018), which allows adding and deleting edges to the graph with a fixed budget for all the graphs; 2) Random denotes an attacker that performs the proposed rewiring operations randomly; 3) Random-s is also based on random rewiring. Note that ReWatt can terminate before using all the budget. We record the actual number of rewiring actions made in our method and only allow the Random-s to take exactly the same number of rewiring actions as ReWatt; 4) ReWatt-n denotes a variant of the ReWatt, where the negative reward is fixed to $- 0 . 5$ for all the graphs in the testing set; and 5) ReWatt-a is a variant of ReWatt, where we allow any nodes in the graph to be the third node $v _ { t h i _ { t } }$ instead of only 2-hop neighbors.
+
+As RL-S2V only allows a fixed budget for the all the graphs, when comparing to it, for ReWatt, we also fix the number of proposed rewiring operations to a fixed number $K$ for all the graphs. Note that a single proposed rewiring operation involves two edges, thus, for a fair comparison, we allow the RL-S2V to take $2 K$ actions (adding/deleting edges). We set $K = 1 , 2 , 3$ in the experiments. To compare with the random selection method and the variants of ReWatt, we use flexible budget, more specially, we allow at most $\boldsymbol { p } \cdot \left| \mathcal { E } _ { i } \right|$ proposed rewiring operations for graph $G _ { i }$ . Here, $p$ is a fixed percentage and we set it to $p = 1 \%$ , $2 \%$ , $3 \%$ in our experiments. We use the success rate as measure to evaluate the performance of the attacker. A graph is said to be successfully attacked if its label is changed when it is modified within the given budget.
+
+The results are shown in Table 1. From the table, we can make the following observations: 1) Compared to RL-S2V, ReWatt can perform more effective attacks. Especially, in the IMDB-MULTI data set, where ReWatt outperforms the RL-S2V with a large margin; 2) ReWatt outperforms the Random method as expected. Especially, ReWatt is much more effective than Random-s which performs exactly the same number of proposed rewiring operations ReWatt. This also indicates that the Random method uses more rewiring operations for successful attacking than ReWatt; 3) The variant ReWatt-a outperforms ReWatt, which means if we do not constraint the rewiring operation to 2-hop neighbors, the performance of ReWatt can be further improved. However, as we discussed in earlier sections, this may lead to more “noticeable” changes of the graph structure; and 4) ReWattn performs worse than our ReWatt, which shows the advancement of using a flexible reward design.
+
+<table><tr><td></td><td colspan="3">REDDIT-MULTI-12K</td><td colspan="3">REDDIT-MULTI-5K</td><td colspan="3">IMDB-MULTI</td></tr><tr><td>K</td><td>1</td><td>2</td><td>3</td><td>1</td><td>2</td><td>3</td><td>1</td><td>2</td><td>3</td></tr><tr><td>ReWatt</td><td>14.4%</td><td>21.6%</td><td>23.4%</td><td>8.99%</td><td>16.9%</td><td>18.0%</td><td>23.0%</td><td>23.3%</td><td>23.3%</td></tr><tr><td>RL-S2V</td><td>9.46%</td><td>18.5%</td><td>21.1%</td><td>4.49%</td><td>16.9%</td><td>18.0%</td><td>2.00%</td><td>6.00%</td><td>3.33%</td></tr><tr><td>P</td><td>1%</td><td>2%</td><td>3%</td><td>1%</td><td>2%</td><td>3%</td><td>1%</td><td>2%</td><td>3%</td></tr><tr><td>ReWatt</td><td>25.2%</td><td>32.9%</td><td>38.7%</td><td>11.2%</td><td>20.2%</td><td>27.0%</td><td>23.0%</td><td>23.0%</td><td>23.3%</td></tr><tr><td>ReWatt-a</td><td>26.1%</td><td>35.1%</td><td>42.8%</td><td>5.60%</td><td>21.3%</td><td>30.3%</td><td>24.3%</td><td>25.0%</td><td>25.6%</td></tr><tr><td>ReWatt-n</td><td>17.6%</td><td>25.7%</td><td>31.1%</td><td>5.60%</td><td>14.6%</td><td>19.1%</td><td>21.3%</td><td>21.3%</td><td>21.6%</td></tr><tr><td>random</td><td>10.3%</td><td>15.7%</td><td>21.6%</td><td>3.30%</td><td>12.4%</td><td>16.9%</td><td>1.33%</td><td>1.33%</td><td>1.66%</td></tr><tr><td>random-s</td><td>6.30%</td><td>6.70%</td><td>9.45%</td><td>5.60%</td><td>6.74%</td><td>11.0%</td><td>1.00%</td><td>1.33%</td><td>1.66%</td></tr></table>
+
+Table 1: Performance comparison in terms of success rate
+
+# 5.2 ATTACKER ANALYSIS
+
+In this subsection, we carry out experiments to analyze how ReWatt’s change in graph structure affects the graph representation u calculated by eq. equation 2 and the logits $\mathbf { P }$ (the output immediately after the softmax layer of the classifier). For convenience, we denote the original graph as $G ^ { o }$ and the attacked graph as $G ^ { a }$ in this section. Correspondingly, the graph representation and logits for the original (attacked) graph are denoted as $\mathbf { u } ^ { o }$ $( \mathbf { u } ^ { a } )$ and $\mathbf { P } ^ { o }$ $( \mathbf { P } ^ { a } )$ , respectively. To measure the difference in graph representation, we used the relative difference in terms of 2-norm defined as $\begin{array} { r } { R C ( \mathbf { u } ^ { o } , \mathbf { u } ^ { a } ) = \frac { \| \mathbf { \bar { u } } ^ { a } - \mathbf { \bar { u } } ^ { o } \| _ { 2 } } { \| \mathbf { u } ^ { o } \| _ { 2 } } } \end{array}$ kua−uok2kuok . The logits denote the probability distribution that the given graph belongs to each of the classes. Thus, we use the KL-divergence Kullback (1997) to measure the difference between the logits of the original and attacked graphs $K L ( \mathbf { P } ^ { o } , \mathbf { P } ^ { a } ) = \sum _ { i = 1 } ^ { C } \mathbf { P } ^ { o } [ i ] \log \left( \frac { \mathbf { P } ^ { o } [ i ] } { \mathbf { P } ^ { a } [ i ] } \right)$ , where $C$ is the number of classes in the data set and $\mathbf { P } [ i ]$ denotes the logit for the $i$ -th class.
+
+We perform the experiments on the REDDIT-MULTI-12K data set under the setting of allowing at most $3 \% \cdot | \mathcal { E } |$ proposed rewiring operations. The results for the graph representation and logits are shown in Figure 1 and Figure 2, respectively. The graphs in the testing set are separated in two groups, one group contains all the graphs successfully attacked by ReWatt (shown in Figure 1a and Figure 2a), and the other one contains those survived from ReWatt’s attack (shown in Figure 1b and Figure 2b). Note that, for comparison, we also include the results of Random-s on these two groups of graphs. In these figures, a single point represents a testing graph, the $\mathbf { X }$ -axis is the ratio $\frac { M } { | { \mathcal { E } } | }$ , where $M$ is the number of rewiring operations ReWatt used before the attacking process terminating. Note that $M$ can be smaller than the budget as the process terminates once the attack successes.
+
+As we can observe from the figures, compared with the Random-s, ReWatt can make more changes to both the graph representation and logits, using exactly the same number of proposed rewiring operations. Comparing Figure 1a with Figure 1b, we find that the perturbation generated by ReWatt affects the graph representation a lot even when it fails to attack the graph. This means our attack is perturbing the graph structure in a right way to fool the classifier, although it fails potentially due to the limited budget. Similar observation can be made when we compare Figure 2a with Figure 2b.
+
+# 6 RELATED WORK
+
+In recent years, adversarial attacks on deep learning models have attracted increasing attention in the area of computer vision. Many deep models are found to be easily fooled by adversarial samples, which are generated by adding deliberately designed unnoticeable perturbation to normal images (Szegedy et al., 2013; Goodfellow et al., 2014). More algorithms with different level access to the target classifier have been proposed, including white-box attack models, which have access to the gradients (Moosavi-Dezfooli et al., 2016; Kurakin et al., 2016; Carlini & Wagner, 2017) and black-box attack model, which have limited access to the target classifier (Chen et al., 2017; Cheng et al., 2018; Ilyas et al., 2018).
+
+![](images/c9820d2ee9a8b72c25a374571cf0a4885313b4c6d8b258ea20986b6a1f04a8d0.jpg)  
+Figure 1: The change of graph representation after attack
+
+![](images/9c77513a8e27a29031e226e0dd277311e53945083e1c4c97ae978cc38291e376.jpg)  
+Figure 2: The change of logits after attack
+
+Most of the aforementioned works are focusing in the computer vision domain, where the data sample can be represented in the continues space. Few attention has been payed into the discrete data structure such as graphs. Graph Neural Networks have been shown to bring impressive advancements to many different graph related tasks such as node classification and graph classification. Recent researches show that the graph neural networks are also venerable to adversarial attacks. (Zugner et al., 2018) proposed a greedy algorithm to perform adversarial attack to node classifi-¨ cation task. Their algorithm tries to change the label of a target node by modifying both the graph structure and node features. (Dai et al., 2018) proposed a deep reinforcement learning based attacker to attack both the node classification and the graph classification task. (Zugner & G ¨ unnemann, ¨ 2019) designed an algorithm to impair the overall performance of node classification based on meta learning. All the three mentioned methods modify the graph structure by adding or deleting edges. A more recent work Wang et al. (2018) on attacking node classifications proposed to modify the graph structure by adding fake nodes. In this work, we propose to modify the graph structure using rewiring, which is shown to make less noticeable changes to the graph structure.
+
+# 7 CONCLUSION
+
+In this paper, we proposed a graph rewiring operation, which affect the graph structure in a less noticeable way than adding/deleting edges. The rewiring operation preserves some basic graph properties such as number of nodes and number of edges. We then designed an attacker ReWatt based on the rewiring operations using reinforcement learning. Experiments in 3 real world data sets show the effectiveness of the proposed framework. Analysis on how the graph representation and logits change while the graph being attacked provide us with some insights of the attacker.
+
+# REFERENCES
+
+Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013.
+
+Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy $( S P )$ , pp. 39–57. IEEE, 2017.
+
+Hau Chan and Leman Akoglu. Optimizing network robustness by edge rewiring: a general framework. Data Mining and Knowledge Discovery, 30(5):1395–1425, 2016.
+
+Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017.
+
+Minhao Cheng, Thong Le, Pin-Yu Chen, Jinfeng Yi, Huan Zhang, and Cho-Jui Hsieh. Queryefficient hard-label black-box attack: An optimization-based approach. arXiv preprint arXiv:1807.04457, 2018.
+
+Hanjun Dai, Hui Li, Tian Tian, Xin Huang, Lin Wang, Jun Zhu, and Le Song. Adversarial attack on graph structured data. In International Conference on Machine Learning, pp. 1123–1132, 2018.
+
+Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In Advances in neural information processing systems, pp. 3844–3852, 2016.
+
+Wendy Ellens, FM Spieksma, P Van Mieghem, A Jamakovic, and RE Kooij. Effective graph resistance. Linear algebra and its applications, 435(10):2491–2506, 2011.
+
+Miroslav Fiedler. Algebraic connectivity of graphs. Czechoslovak mathematical journal, 23(2): 298–305, 1973.
+
+Arpita Ghosh and Stephen Boyd. Growing well-connected graphs. In Proceedings of the 45th IEEE Conference on Decision and Control, pp. 6605–6611. IEEE, 2006.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017.
+
+Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018.
+
+Kristian Kersting, Nils M. Kriege, Christopher Morris, Petra Mutzel, and Marion Neumann. Benchmark data sets for graph kernels, 2016. URL http://graphkernels.cs.tu-dortmund. de.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016.
+
+Solomon Kullback. Information theory and statistics. Courier Corporation, 1997.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016.
+
+Benjamin A Miller, Mustafa C¸ amurcu, Alexander J Gomez, Kevin Chan, and Tina Eliassi-Rad. Improving robustness to attacks against vertex classification. 2019.
+
+Bojan Mohar, Y Alavi, G Chartrand, and OR Oellermann. The laplacian spectrum of graphs. Graph theory, combinatorics, and applications, 2(871-898):12, 1991.
+
+Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016.
+
+Aliaksei Sandryhaila and Jose MF Moura. Discrete signal processing on graphs: Frequency analysis. IEEE Transactions on Signal Processing, 62(12):3042–3054, 2014.
+
+David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. arXiv preprint arXiv:1211.0053, 2012.
+
+Gilbert W Stewart. Matrix perturbation theory. 1990.
+
+Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018.
+
+Ali Sydney, Caterina Scoglio, and Don Gruenbacher. Optimizing algebraic connectivity by edge rewiring. Applied Mathematics and computation, 219(10):5465–5479, 2013.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013.
+
+Xiaoyun Wang, Joe Eaton, Cho-Jui Hsieh, and Felix Wu. Attack graph convolutional networks by adding fake nodes. arXiv preprint arXiv:1810.10751, 2018.
+
+Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1365–1374. ACM, 2015.
+
+Rex Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L Hamilton, and Jure Leskovec. Hierarchical graph representation learning withdifferentiable pooling. arXiv preprint arXiv:1806.08804, 2018.
+
+Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018.
+
+Marinka Zitnik, Rok Sosic, Marcus W. Feldman, and Jure Leskovec. Evolution of resilience in ˇ protein interactomes across the tree of life. Proceedings of the National Academy of Sciences, 116(10):4426–4433, 2019. ISSN 0027-8424. doi: 10.1073/pnas.1818013116. URL https: //www.pnas.org/content/116/10/4426.
+
+Daniel Zugner, Amir Akbarnejad, and Stephan G ¨ unnemann. Adversarial attacks on neural networks ¨ for graph data. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 2847–2856. ACM, 2018.
+
+Daniel Zugner and Stephan G ¨ unnemann. Adversarial attacks on graph neural networks via meta ¨ learning. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ Bylnx209YX.
+
+# A GRAPH LAPLACIAN BASED MEASURES
+
+Many important graph properties are based on the eigenvalues of the Laplacian matrix of a graph (Chan & Akoglu, 2016). Here we list few:
+
+• Algebraic Connectivity The algebraic connectivity of a graph $G$ is the second-smallest eigenvalue of its Laplacian matrix (Fiedler, 1973). Note that we only consider connected graphs in this work, so it is always larger than 0. The larger the algebraic connectivity is, the more difficult it is to separate the graph into components (i.e., more edges need to be removed). The algebraic connectivity has previously been applied to measure network robustness Sydney et al. (2013).
+
+• Effective Graph Resistance The effective graph resistance is a graph measure derived from the field of electric circuit analysis, where it is defined as the summation of effective resistance over all node pairs (Ellens et al., 2011). The effective graph resistance can be represented using the eigenvalues of Laplacian matrix as follows (Ellens et al., 2011)
+
+$$
+R _ { e } = | \mathcal { V } | \cdot \sum _ { i = 2 } ^ { | \mathcal { V } | } \lambda _ { i } .
+$$
+
+By Corollary 2, we can represent the change of the algebraic connectivity $\lambda _ { 2 }$ as:
+
+$$
+\Delta \lambda _ { 2 } = ( 2 { \bf x } _ { 2 } [ f i r ] - { \bf x } _ { 2 } [ t h i ] - { \bf x } _ { 2 } [ s e c ] ) ( { \bf x } _ { 2 } [ s e c ] - { \bf x } _ { 2 } [ t h i ] )
+$$
+
+According to the above discussion, $\Delta \lambda _ { 2 }$ is expected to be smaller for the operation of rewiring to 2-hop neighbor. Thus, the rewiring to 2-hop neighbor operation is expected to perturb the algebraic connectivity less compared with adding an edge between two nodes that are far away from each other. A similar argument can be built for effective graph resistance.
+
+# B PROOF OF COLLARY 1
+
+Corollary 2. For a given graph $G$ with Laplacian matrix $\mathbf { L }$ , one proposed rewiring operation $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ affects the eigen-value $\lambda _ { i }$ by $\Delta \lambda _ { i }$ , for $i = 1 , \ldots , | \nu |$ , where
+
+$$
+\Delta { \lambda } _ { i } = ( 2 { \bf { x } } _ { i } [ f i r ] - { \bf { x } } _ { i } [ t h i ] - { \bf { x } } _ { i } [ s e c ] ) ( { \bf { x } } _ { i } [ s e c ] - { \bf { x } } _ { i } [ t h i ] )
+$$
+
+where $\mathbf { x } _ { i } [ i n d e x ]$ denotes the index-th value of the eigenvector $\mathbf { x } _ { i }$
+
+Proof. Let $\Delta \mathbf { L }$ denotes the change in the Laplacian matrix after applying the rewiring operation $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ to graph $G$ . Then we have $\Delta { \bf L } [ f i r , s e c ] = \Delta { \bf L } [ s e c , f i r ] = 1$ , $\Delta \mathbf { L } [ f i r , t h i ] =$ $\Delta { \bf L } [ t h i , f i r ] = - 1$ , $\Delta \mathbf { L } [ s e c , s e c ] = - 1$ , $\Delta \mathbf { L } [ t h i , t h i ] = 1$ and 0 elsewhere. Thus
+
+$$
+\begin{array} { r l } & { \Delta \lambda _ { i } = \mathbf { x } _ { i } ^ { T } \Delta \mathbf { L } \mathbf { x } _ { i } } \\ & { \quad \quad = 2 \mathbf { x } _ { i } [ f i r ] \mathbf { x } _ { i } [ s e c ] - \mathbf { x } _ { i } [ s e c ] ^ { 2 } + \mathbf { x } _ { i } [ t h i ] ^ { 2 } - 2 \mathbf { x } _ { i } [ f i r ] \mathbf { x } _ { i } [ t h i ] } \\ & { \quad = \mathbf { x } _ { i } [ t h i ] ^ { 2 } - \mathbf { x } _ { i } [ s e c ] ^ { 2 } + 2 \mathbf { x } _ { i } [ f i r ] ( \mathbf { x } _ { i } [ s e c ] - \mathbf { x } _ { i } [ t h i ] ) } \\ & { \quad = ( 2 \mathbf { x } _ { i } [ f i r ] - \mathbf { x } _ { i } [ t h i ] - \mathbf { x } _ { i } [ s e c ] ) ( \mathbf { x } _ { i } [ s e c ] - \mathbf { x } _ { i } [ t h i ] ) } \end{array}
+$$
+
+which completes the proof.
+
+# C EMPIRICAL INVESTIGATION OF THE REWIRING OPERATION
+
+In this section, we conduct experiments to empirically show the advancements of the proposed rewiring operator compared with the adding/deleting edge operator. We compare them from two perspectives: 1) connectivity after the attack and 2) change in eigenvalues after the attack. The experiments are carried out on the REDDIT-MULTI-12K dataset. On each of the graph successfully attacked by ReWatt, we perform exactly the same number of deleting/adding edge operator on it. For connectivity, the average number of components in the clean graphs is 2.6, this number becomes 3.02 after the rewiring attack while it becomes 5.2 after the deleting/adding edges attack. On the other hand, only $2 0 \%$ of the graphs get more disconnected (having more components) after ReWattattack than the original ones, while $8 7 \%$ of the graphs get more disconnected after the adding/deleting edges attack. Clearly, the rewiring operator is less likely to disconnect the graph. The comparison of the change in eigenvalues is shown in Figure 3, where we compare the change in different eigenvalues of the graphs after these two attacks. Specifically, we first compute the average relative change in the $i$ -th eigenvalue after both attacks as follows:
+
+$$
+r _ { \lambda _ { i } } = \frac { | \lambda _ { i } ^ { o r i } - \lambda _ { i } ^ { a t t a c k } | } { \lambda _ { i } ^ { o r i } } ,
+$$
+
+where $\lambda _ { i } ^ { o r i }$ denotes the $i$ -th eigenvalue of the clean graph while $\lambda _ { i } ^ { a t t a c k }$ denotes the $i$ -th eigenvalue of the attacked graph. We then take the average of the above value over all the succeeded graphs, which we denoted as $\bar { r } _ { \lambda _ { i } }$ . Specially, we use $\bar { r } _ { \lambda _ { i } } ^ { r e }$ to denote the average change ratio after $R e W a t t$ while using r¯d/λ to denote the average change ratio after deleting/adding edge attack. To compare the these two attacks, we calculate r¯d/aλ / $\bar { r } _ { \lambda _ { i } } ^ { d / a } / \bar { r } _ { \lambda _ { i } } ^ { r e }$ and the results are shown in Figure 3. The results show that in most of the cases, the deleting/adding edges attack makes much more changes to the eigenvalues as the value r¯d/aλi / $\bar { r } _ { \lambda _ { i } } ^ { d / a } / \bar { r } _ { \lambda _ { i } } ^ { r e }$ is way larger than 1.
+
+By conducting these two experiments, we empirically conclude that the proposed re-wiring operator makes more subtle changes to graphs than existing methods.
+
+![](images/90368341caeeddcf829db276aed7c06c67173ec29cea181419e67dddb542fdda.jpg)  
+Figure 3: Comparison in the change of eigenvalues
+
+# D STATISTICS OF THE DATASETS
+
+The statistics of the datasets are given in Table 2. In this table, #nodes denotes the average number of nodes over all graphs and #edges denotes the average number of edges over all graphs. ACC denotes the mean of Average Clustering Coefficient (ACC) over all graphs. GCC denotes the mean of Global Clustering Coefficient (GCC) over all graphs.
+
+Table 2: Statistics of the data sets   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>#graphs</td><td rowspan=1 colspan=1>#labels</td><td rowspan=1 colspan=1>#nodes</td><td rowspan=1 colspan=1>#edges</td><td rowspan=1 colspan=1>ACC</td><td rowspan=1 colspan=1>GCC</td></tr><tr><td rowspan=1 colspan=1>REDDIT-MULTI-12K</td><td rowspan=1 colspan=1>11,929</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>391.41</td><td rowspan=1 colspan=1>456.89</td><td rowspan=1 colspan=1>0.0331</td><td rowspan=1 colspan=1>0.0087</td></tr><tr><td rowspan=1 colspan=1>REDDIT-MULTI-5K</td><td rowspan=1 colspan=1>4,999</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>508.52</td><td rowspan=1 colspan=1>594.87</td><td rowspan=1 colspan=1>0.0268</td><td rowspan=1 colspan=1>0.0038</td></tr><tr><td rowspan=1 colspan=1>IMDB-MULTI</td><td rowspan=1 colspan=1>1,500</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>65.94</td><td rowspan=1 colspan=1>0.968</td><td rowspan=1 colspan=1>0.8955</td></tr></table>

parse/train/B1eXygBFPH/B1eXygBFPH_content_list.json

@@ -0,0 +1,1658 @@
+[
+    {
+        "type": "text",
+        "text": "ATTACKING GRAPH CONVOLUTIONAL NETWORKS VIA REWIRING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            823,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            400,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph Neural Networks (GNNs) have boosted the performance of many graph related tasks such as node classification and graph classification. Recent researches show that graph neural networks are vulnerable to adversarial attacks, which deliberately add carefully created unnoticeable perturbation to the graph structure. The perturbation is usually created by adding/deleting a few edges, which might be noticeable even when the number of edges modified is small. In this paper, we propose a graph rewiring operation which affects the graph in a less noticeable way compared to existing operators. We then use reinforcement learning to learn the attack strategy based on the proposed rewiring operation. Experiments on real world graphs demonstrate the effectiveness of the proposed framework. To understand the proposed framework, we further analyze how its generated perturbation to the graph structure affects the output of the target model and the advantages of the rewiring operation. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            474,
+            336,
+            491
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Graph structured data are ubiquitous in many real world applications. Various data from different domains, such as social networks, molecular graphs and transportation networks can all be modeled as graphs. Recently, increasing effort has been devoted towards developing deep neural networks on graph structured data. This stream of works, which is known as Graph Neural Networks (GNN) has shown to enhance the performance in many graph related tasks such as node classification (Kipf & Welling, 2016; Hamilton et al., 2017) and graph classification (Bruna et al., 2013; Defferrard et al., 2016; Ying et al., 2018; Zhang et al., 2018). ",
+        "bbox": [
+            174,
+            507,
+            825,
+            603
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent researches have shown that deep neural networks are highly vulnerable to adversarial attacks (Szegedy et al., 2013; Goodfellow et al., 2014; Kurakin et al., 2016; Carlini & Wagner, 2017). In computer vision, performing an adversarial attack is to add deliberately created, but unnoticeable, perturbation to a given image such that the deep model misclassifies the perturbed image. Unlike image data, which can be represented in the continuous space, graph structured data is discrete. Few efforts have been made to investigate the robustness of graph neural networks against adversarial attacks. Only recently, such researches about adversarial attacks on graph structured data started to emerge. A greedy algorithm is proposed to attack the semi-supervised node classification task (Zugner et al., 2018). The method deliberately tries to modify the graph structure and node ¨ features such that the label of a targeted node can be changed. A reinforcement learning based algorithm is proposed to attack both node classification and graph classification task by only modifying the graph structure(Dai et al., 2018). A meta-learning based attack method is designed to impair the overall performance of the node classification task(Zugner & G ¨ unnemann, 2019). For the majority ¨ of existing works, the graph structure is modified by adding or deleting edges. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To ensure that the difference between the attacked graph and the original graph is “unnoticeable”, the number of actions (adding/deleting edges) that can be taken by the attacking algorithms is usually constrained by a budget. However, even when this budget is small, adding or deleting edges can still make “noticeable” changes to the graph structure (Miller et al., 2019). For example, it is evident that many important graph properties are based on eigenvalues and eigenvectors of the Laplacian matrix of the graph (Chan & Akoglu, 2016); while adding or deleting an edge can make remarkable changes on the eigenvalues/eigenvectors of the graph Laplacian (Ghosh & Boyd, 2006). Thus, in this work, we propose a new operation based on graph rewiring. A single rewiring operation involves three nodes $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ , where we remove the existing edge between $v _ { f i r }$ and $v _ { s e c }$ and add edge between $v _ { f i r }$ and $v _ { t h i }$ . Note that $v _ { t h i }$ is constraint to be the 2-hop neighbor of $v _ { f i r }$ in our setting. It is obvious that the proposed rewiring operation preserves some basic properties of the graph such as number of nodes and edges, total degrees of the graph and etc, while operations like adding and deleting edges cannot. Furthermore, the proposed rewiring operation affects some of the important measures based on graph Laplacian such as algebraic connectivity in a smaller way than adding/deleting edges, which is theoretically demonstrated in Section 4.1. In addition, the rewiring operation is a more natural way to modify the graph. For example, in biology, the evolution of DNA and amino acid sequences can lead to pervasive rewiring of protein–protein interactions (Zitnik et al., 2019). ",
+        "bbox": [
+            174,
+            813,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we aim to construct adversarial examples by performing rewiring operations for the task of graph classification. More specifically, we treat the process of applying a series of rewiring operations to a given graph as a discrete Markov decision process (MDP) and use reinforcement learning to learn how to make these decisions. We demonstrate the effectiveness of the proposed algorithm on real-world graphs. Then we further analyze how the adversarial changes in the graph structure affect both the graph embedding learned by the graph neural network model and the output label and illustrate the advantages of the rewiring operation. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            367,
+            326,
+            383
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce notations and the target graph convolutional model we seek to attack. We denote a graph as $G = \\{ \\nu , \\mathcal { E } \\}$ , where $\\mathcal { V } = \\{ v _ { 1 } , \\ldots , v _ { | \\mathcal { V } | } \\}$ and $\\mathcal { E } = \\{ e _ { 1 } , \\ldots , e _ { | \\mathcal { E } | } \\}$ are the sets of nodes and edges, respectively. The edges describe the relations between nodes, which can be described by an adjacency matrix $\\mathbf { A } \\in \\{ \\bar { 0 } , 1 \\} ^ { | \\mathcal { V } | \\times | \\mathcal { V } | }$ . $\\mathbf { A } _ { i j } = 1$ means $v _ { i }$ and $v _ { j }$ are connected, 0 otherwise. Each node in the graph has some features that are associated with it. These features are represented as a matrix $\\mathbf { X } \\in \\mathbb { R } ^ { | \\bar { \\nu } | \\times d }$ , where the $i$ -th row of $\\mathbf { X }$ denotes the node features of node $v _ { i }$ and $d$ is the dimension of features. Thus, an attributed graph can be represented as $G = \\{ \\mathbf { A } , \\mathbf { X } \\}$ . ",
+        "bbox": [
+            173,
+            397,
+            825,
+            498
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 GRAPH CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            513,
+            387,
+            529
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In the setting of graph classification, we are given a set of graphs $\\mathcal { G } = \\{ G _ { i } \\}$ . Each of these graphs $G _ { i }$ is associated with a label $y _ { i }$ . The task is to build a good classifier using the given set of graphs such that it can make correct predictions when new unseen graphs are fed into it. A graph classifier parameterized by $\\theta$ can be represented as $f ( G | \\theta ) = y ^ { o }$ , where $y ^ { o }$ denotes the label of a graph $G \\in { \\mathcal { G } }$ predicted by the classifier. The parameters $\\theta$ in the classifier $f ( \\cdot | \\theta )$ can be learned by solving the following optimization problem $\\begin{array} { r } { \\operatorname* { m i n } _ { \\theta } \\sum _ { i } L ( f ( G _ { i } | \\theta ) , y _ { i } ) } \\end{array}$ , where $L ( \\cdot , \\cdot )$ is used to measure the difference between the predicted and ground truth labels. Cross entropy is a commonly adopted measurement for $L ( \\cdot , \\cdot )$ . ",
+        "bbox": [
+            173,
+            539,
+            825,
+            652
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 GRAPH CONVOLUTION NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            667,
+            460,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Graph Neural Networks have been shown to be effective in graph representation learning. These models usually learn node representations by iteratively aggregating, transforming and propagating node information. In this work, we adopt the graph convolutional networks (GCN) (Kipf & Welling, 2016). A graph convolutional layer in the GCN framework can be represented as ",
+        "bbox": [
+            174,
+            694,
+            823,
+            750
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a60241a8b63242757749c38f7df17d4e5a3ad98d1fac0396092367591c2cf925.jpg",
+        "text": "$$\n\\mathbf { F } ^ { j } = R e L U ( \\mathbf { D } ^ { - \\frac { 1 } { 2 } } \\mathbf { A } \\mathbf { D } ^ { - \\frac { 1 } { 2 } } \\mathbf { F } ^ { j - 1 } \\mathbf { W } ^ { j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            752,
+            622,
+            773
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { F } ^ { j } \\in \\mathbb { R } ^ { N \\times d _ { j } }$ is the output of the $j$ -th layer and $\\mathbf { W } ^ { j }$ represents the parameters of this layer. A GCN model usually consists of $J$ graph convolutional layers, with $\\mathbf { F } ^ { 0 } \\equiv \\mathbf { X }$ . The output of the GCN model is $\\mathbf { F } ^ { J }$ , which is denote as $\\mathbf { F }$ for convenience. To obtain a graph level embedding $\\mathbf { u } _ { G }$ for graph $G$ to perform graph classification, we apply a global pooling over the node embeddings. ",
+        "bbox": [
+            174,
+            777,
+            823,
+            835
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b3d910361afcbdc4ac230d7ee6999313078183887c720c989d170aba3e25bf20.jpg",
+        "text": "$$\n\\mathbf { u } _ { G } = p o o l ( \\mathbf { F } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            838,
+            549,
+            854
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Different global pooling functions can be used, and we adopt the max pooling in this work. A multilayer perceptron (MLP) and softmax layer are then sequentially applied on the graph embedding to predict the label of the graph ",
+        "bbox": [
+            174,
+            858,
+            825,
+            901
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eccc5c518d83ee937ad3da9e49bd58cb6de9085214ec6bdf490bbdcf5714f834.jpg",
+        "text": "$$\ny ^ { o } = \\mathrm { a r g m a x } ~ s o f t m a x ( M L P ( \\mathbf { u } _ { G } | \\mathbf { W } _ { M L P } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            904,
+            650,
+            921
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $M L P ( \\cdot | \\mathbf { W } _ { M L P } )$ denotes the multilayer perceptron with parameters as ${ \\bf W } _ { M L P }$ . A GCNbased classifier for graph classification can be described using eq. equation 1, equation 2 and equation 3 as introduced above. For simplicity, we summarize it as $y ^ { \\bar { o } } = \\bar { f } _ { G C N } ( G | \\bar { \\theta _ { G C N } } )$ , where $\\theta _ { G C N }$ includes all the parameters in the model. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROBLEM FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            179,
+            416,
+            195
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this work, we aim to build an attacker $\\tau$ that takes a graph as input and modify the structure of the graph to fool a GCN classifier. Modifying a graph structure is equivalent to modify its adjacency matrix. The function of the attacker can be represented as $\\tilde { G } = \\bar { \\mathcal { T } } ( G ) = \\{ \\mathcal { T } ( \\mathbf { A } ) , \\dot { \\mathbf { X } } \\} = \\{ \\tilde { \\mathbf { A } } , \\mathbf { X } \\}$ . Given a classifier $f ( \\cdot )$ , the goal of the attacker is to modify the graph structure so that the classifier outputs a different label from what it originally predicted. Note here, we neglect the $\\theta$ inside $f ( \\cdot )$ , as the classifier is already trained and fixed. Mathematically, the goal of the attacker can be represented as: $f ( { \\mathcal { T } } ( G ) ) \\neq f ( G )$ . ",
+        "bbox": [
+            173,
+            210,
+            825,
+            311
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As described above, the attacker $\\tau$ is specifically designed for a given classifier $f ( \\cdot )$ . To reflect this in the notation, we now denote the attacker for the classifier $f ( \\cdot )$ as $\\mathcal { T } _ { f }$ . In our work, the attacker $\\mathcal { T } _ { f }$ has limited knowledge of the classifier. The only information the attacker can get from the classifier is the label of (modified) graphs. In other words, the classifier $f ( \\cdot )$ is treated as a black-box model for the attacker $\\mathcal { T } _ { f }$ . ",
+        "bbox": [
+            174,
+            316,
+            825,
+            388
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An important constraint to the attacker $\\mathcal { T } _ { f }$ is that it is only allowed to make “unnoticeble” changes to the graph structure. To account for this, we propose the rewiring operation, which is supposed to make more subtle changes than adding or deleting edges. We will show that the rewiring operation can better preserve a lot of important properties of the graph compared to adding or deleting edges in Section 4.1. We also empirically compare the rewiring operation with the deleting/adding edges in Appendix C. The definition of the proposed rewiring is given below: ",
+        "bbox": [
+            174,
+            393,
+            825,
+            478
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. $A$ rewiring operation a involves three nodes and it can be denoted as ${ \\bf a } \\_ =$ $\\{ v _ { f i r } , v _ { s e c } , v _ { t h i } \\}$ , where $\\breve { v } _ { s e c } \\in N ^ { 1 } ( v _ { f i r } )$ and $v _ { t h i } \\in N ^ { 2 } ( v _ { f i r } ) / N ^ { 1 } ( v _ { f i r } )$ . $N ^ { k } ( v _ { f i r } )$ denotes the $k$ -th hop neighbors of $v _ { f i r }$ and the sign / stands for exclusion. The rewiring operation deletes the existing edge between nodes $v _ { f i r }$ and $v _ { s e c } ,$ , while adding an edge to connect nodes $v _ { f i r }$ and $v _ { t h i }$ . ",
+        "bbox": [
+            174,
+            482,
+            825,
+            537
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The attacker $\\mathcal { T } _ { f }$ is given a budget of $K$ proposed rewiring operations to modify the graph structure. A straightforward way to set $K$ is choosing a small fix number. However, it is likely that graphs in a given data set have various graph sizes. The same number of rewiring operations can affect the graphs of different size in various magnitude. Hence, a more suitable way is to allow flexible number of rewiring operations according to the graph size. Thus, we propose to use $K = p \\cdot | { \\mathcal { E } } |$ for a given graph $G$ , where $p \\in ( 0 , 1 )$ is a ratio. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The process of the attacker on a graph $G$ can be now denoted as $\\mathcal { T } _ { f } ( G )  ( a _ { 1 } , a _ { 2 } , \\dotsc , a _ { M } ) [ G ] .$ , where the right hand part means to sequentially apply the rewiring operations $a _ { 1 } , \\dots , a _ { M }$ to the graph $G$ , and $M$ is the number of rewiring operations taken with $M \\leq K$ . ",
+        "bbox": [
+            176,
+            640,
+            825,
+            683
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 REWIRING-BASED ATTACK TO GRAPH CONVOLUTIONAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            702,
+            779,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Next, we first discuss the properties of the proposed rewiring operation to show its advantages. We then introduce the proposed attacking framework ReWatt based on reinforcement learning and rewiring. ",
+        "bbox": [
+            174,
+            733,
+            825,
+            776
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 PROPERTIES OF THE PROPOSED REWIRING OPERATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            792,
+            598,
+            808
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The proposed rewiring operation has several advantages compared to simply adding or deleting edges. More empirical discussions can be found in Appendix C. One obvious advantage of the proposed rewiring operation is that it does not change the number of nodes, the number of edges and the total degree of a graph. However, operations like “adding” or “deleting” edges may change those properties. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Many important graph properties are based on the eigenvalues of the Laplacian matrix of a graph (Chan & Akoglu, 2016) such as Algebraic Connectivity Fiedler (1973) and Effective Graph ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Resistance Ellens et al. (2011). A detailed description of Algebraic Connectivity and Effective Graph Resistance are given in Appendix A. Next, we demonstrate that the proposed rewiring operation is likely to make smaller changes to eigenvalues, which result in unnoticeable changes under graph Laplacian based measures. For a graph $G$ with $\\mathbf { A }$ as its adjacency matrix, its Laplacian matrix $\\mathbf { L }$ is defined as $\\mathbf { L } = \\mathbf { D } - \\mathbf { A }$ , where $\\mathbf { D }$ is the diagonal degree matrix (Mohar et al., 1991). Let $\\lambda _ { 1 } , \\ldots , \\lambda _ { | \\nu | }$ denote the eigenvalues of the Laplacian matrix arranged in the increasing order with $\\mathbf { x } _ { 1 } , \\ldots , \\mathbf { x } _ { | \\mathcal { V } | }$ being the corresponding eigenvectors. We show how a single proposed rewiring operation affects the eigenvalues. Our analysis is based on the following lemma: ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lemma 1. (Stewart, 1990) Let $\\left( \\alpha _ { i } , \\mathbf { h } _ { i } \\right)$ be the eigen-pairs of a symmetric matrix $\\mathbf { M } \\in \\mathbb { R } ^ { N \\times N }$ Given a perturbation $\\Delta \\mathbf { M }$ to matrix M, its eigenvalues can be updated by $\\Delta \\alpha _ { i } = \\mathbf { h } _ { i } ^ { T } \\Delta \\mathbf { M } \\mathbf { h } _ { i }$ . ",
+        "bbox": [
+            173,
+            218,
+            821,
+            247
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proof can be found in (Stewart, 1990). Using this lemma, we have the following corollary Corollary 1. For a given graph $G$ with Laplacian matrix $\\mathbf { L }$ , one proposed rewiring operation $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ affects the eigen-value $\\lambda _ { i }$ by $\\Delta \\lambda _ { i } ,$ , for $i = 1 , \\ldots , | \\nu |$ , where ",
+        "bbox": [
+            174,
+            256,
+            823,
+            303
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcb26affee26503eb8ef53c271bc96fc7bef70b7467388787984704639614ca2.jpg",
+        "text": "$$\n\\Delta { \\lambda } _ { i } = ( 2 { \\bf { x } } _ { i } [ f i r ] - { \\bf { x } } _ { i } [ t h i ] - { \\bf { x } } _ { i } [ s e c ] ) ( { \\bf { x } } _ { i } [ s e c ] - { \\bf { x } } _ { i } [ t h i ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            306,
+            689,
+            323
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x } _ { i } [ i n d e x ]$ denotes the index-th value of the eigenvector $\\mathbf { x } _ { i }$ ",
+        "bbox": [
+            173,
+            327,
+            606,
+            342
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proof can be found in Appendix B. ",
+        "bbox": [
+            174,
+            352,
+            433,
+            366
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, each eigenvalue $\\lambda _ { i }$ of the Laplacian matrix measures the “smoothness” of its corresponding eigenvector $\\mathbf { x } _ { i }$ (Shuman et al., 2012; Sandryhaila & Moura, 2014). The “smoothness” of an eigenvector measures how different its elements are from their neighboring nodes. Thus, the first few eigenvectors with relatively small eigenvalues are rather “smooth”. Note that in the proposed rewiring operation, $v _ { s e c }$ is the direct neighbor of $v _ { f i r }$ and $v _ { t h i }$ is the 2-hop neighbor of $v _ { f i r }$ . Thus, the difference ${ \\bf x } _ { i } [ f i r ] - { \\bf x } _ { i } [ t h i ]$ is expected to be smaller than the difference ${ \\bf x } _ { i } [ f i r ] - { \\bf x } _ { i } [ c \\dot { a } n ]$ , where $\\mathbf { x } _ { i } [ c a n ]$ can be any other node that is further away. This means that the proposed rewiring operation (to 2-hop neighbors) is likely to make smaller changes to the first few eigenvalues than rewiring to any further away nodes or adding an edge between two nodes that are far away from each other. ",
+        "bbox": [
+            173,
+            372,
+            825,
+            498
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.2 GRAPH ADVERSARIAL ATTACK WITH REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            515,
+            679,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Given a graph $G$ , the process of the attacker $\\tau$ is a general decision making process $M \\ =$ $( \\boldsymbol { S } , \\mathcal { A } , \\boldsymbol { P } , \\boldsymbol { R } )$ , where $\\mathcal { A } \\stackrel { \\bf { \\bar { \\Delta } } } { = } \\{ a _ { t } \\}$ is the set of actions, which consists of all valid rewiring operations, ${ \\cal { S } } = \\{ s _ { t } \\}$ is the set of states that consists of all possible intermediate and final graphs after rewiring, $P$ is the transition dynamics that describes how a rewiring action $a _ { t }$ changes the graph structure $p ( s _ { t + 1 } | , s _ { t } , \\ldots , s _ { 1 } , \\bar { a _ { t } } )$ . $R$ is the reward function, which gives the reward for the action taken at a given state. Thus, the procedure of attacking a graph can be described by a trajectory $( s _ { 1 } , a _ { 1 } , r _ { 1 } , \\ldots , s _ { M } , a _ { M } , r _ { M } )$ , where $s _ { 1 } ~ = ~ G$ . The key point for the attacker is to learn how to make the decision of picking a suitable rewiring action when at the state $s _ { t }$ . This can be done by learning a policy network to get the probability $p ( a _ { t } | s _ { t } , \\ldots , s _ { 1 } )$ and sample the rewiring operation correspondingly. Modelling in this way, the decision making at a state $s _ { t }$ is dependant on all its previous states, which could be difficult to model due to the long-term dependency. It is easy to notice that the intermediate states $s _ { t }$ are all predicted to have the same label as the original graph. Thus, we can treat each of the states as a brand new graph to be attacked regardless of what leads to it. That is to say, the decision making at the state $s _ { t }$ can be solely dependant on the current state, $p ( a _ { t } | s _ { t } , \\ldots , s _ { 1 } ) = p ( a _ { t } | s _ { t } )$ . Thus, we model the process of attack as a Markov Decision Process (MDP) Sutton & Barto (2018). Hence, we adopt reinforcement learning to learn how to make effective decisions. We name the proposed framework as ReWatt. The key elements of the environment for the reinforcement learning are defined as follows: ",
+        "bbox": [
+            173,
+            540,
+            825,
+            790
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "State Space The state space of the environment consists of all the intermediate graphs generated after the possible rewiring operations. ",
+        "bbox": [
+            176,
+            797,
+            820,
+            825
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Action Space The action space consists of the valid rewiring operations as defined in Definition 1. ",
+        "bbox": [
+            174,
+            829,
+            816,
+            844
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "State Transition Dynamics Given an action (rewiring operation) $a _ { t } = \\{ v _ { f i r } , v _ { s e c } , v _ { t h i } \\}$ at state $s _ { t }$ The next state $s _ { t + 1 }$ is achieved by deleting the edge between $v _ { f i r }$ and $v _ { s e c }$ in the current state $s _ { t }$ and adding an edge to connect $v _ { f i r }$ with $v _ { t h i }$ . ",
+        "bbox": [
+            174,
+            849,
+            820,
+            892
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Reward Design The main goal of the attacker is to make the classifier $f ( \\cdot )$ predict a different label than originally predicted. We also encourage the attacker to take as few actions as possible so that the modification to the graph structure is minimal. Thus, we assign a positive reward when the attack is successful and assign a negative reward for each action step taken. The reward $R ( s _ { t } , a _ { t } )$ is given as ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            143
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2885c2cbe001db4fa29c339d88a3d0694d92dea716778517d6af52af5ffe1b53.jpg",
+        "text": "$$\nR ( s _ { t } , a _ { t } ) = { \\left\\{ \\begin{array} { l l } { ~ 1 ~ } & { { \\mathrm { i f } } ~ f ( s _ { t } ) \\neq f ( s _ { 1 } ) ; } \\\\ { n _ { r } ~ } & { { \\mathrm { i f } } ~ f ( s _ { t } ) = f ( s _ { 1 } ) . } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            140,
+            624,
+            176
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $n _ { r }$ is the negative reward to penalize each step taken. Similar to how we set a flexible rewiring budget $K$ , here we propose to use $\\begin{array} { r } { \\dot { n } _ { r } = - \\frac { 1 } { K } = - \\frac { 1 } { p \\cdot | \\mathcal { E } | } } \\end{array}$ − 1p·|E| , which depends on the size of the graph. ",
+        "bbox": [
+            174,
+            176,
+            825,
+            208
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Termination The attack process will stop either when the number of actions reaches the budget $K$ or the attacker successfully “changed” the label of the slightly modified graph. ",
+        "bbox": [
+            173,
+            210,
+            823,
+            241
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 POLICY NETWORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            256,
+            346,
+            270
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we introduce the policy network to learn the policy $p ( a _ { t } | s _ { t } )$ on top of the graph representations learned by GCN. However, this GCN is different from the target classifier one, since it has 2 convectional layers. To choose a valid proposed rewiring action, we decompose the rewiring action to 3 steps: 1) choosing an edge $e _ { t } = ( v _ { e _ { 1 } } , v _ { e _ { 2 } } )$ from the set of edges of the intermediate graph $s _ { t } ; 2 )$ determining $v _ { e _ { t 1 } }$ or $v _ { e _ { t 2 } }$ to be ${ \\boldsymbol { v } } _ { f i r _ { t } }$ and the other to be $v _ { s e c _ { t } }$ ; and 3) choosing the third node $v _ { t h i _ { t } }$ from $N _ { s _ { t } } ^ { 2 } ( v _ { f i r _ { t } } ) / N _ { s _ { t } } ^ { 1 } ( v _ { f i r _ { t } } )$ . Correspondingly, we decompose $p ( a _ { t } | s _ { t } )$ as follows ",
+        "bbox": [
+            173,
+            281,
+            825,
+            369
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7cdd786bb9ee0a91c2066ceb3504e79629ff49bb25f66253d27e492db2aabbc8.jpg",
+        "text": "$$\np ( a _ { t } | s _ { t } ) = p _ { e d g e } ( e _ { t } | s _ { t } ) \\cdot p _ { f i r } ( v _ { f i r _ { t } } | e _ { t } , s _ { t } ) \\cdot p _ { t h i } ( v _ { t h i _ { t } } | v _ { f i r _ { t } } , e _ { t } , s _ { t } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            277,
+            375,
+            720,
+            391
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We design three policy networks based on GCN to estimate the three distributions in the right hand of the equation equation 5, which will be introduced next. To select an edge from the edge set $\\mathcal { E } _ { s _ { t } }$ , we generate the edge representation from the node representations $\\mathbf { F } _ { s _ { t } } \\in \\mathbb { R } ^ { | \\mathcal { V } _ { s _ { t } } | \\times d _ { F } }$ learned by GCN. For an edge $\\boldsymbol { e } ~ = ~ \\left( v _ { e _ { 1 } } , v _ { e _ { 2 } } \\right)$ , the edge representation can be represented as $\\textbf { e } = \\ c o n c a t ( \\mathbf { u } _ { s _ { t } } , h ( \\mathbf { F } _ { s _ { t } } [ e _ { 1 } , : ] , \\mathbf { F } _ { s _ { t } } [ e _ { 2 } , : ] ) )$ , where $\\mathbf { u } _ { s _ { t } }$ is the graph representation of the state $s _ { t }$ , $h ( \\cdot , \\cdot )$ is a function to combine the two node representations and $c o n c a t ( \\cdot , \\cdot )$ denotes the concatenation operation. We include $\\mathbf { u } _ { s t }$ in the representation of the edge to incorporate the graph information when making the decision. The representation of all the edges in $\\mathcal { E } _ { s _ { t } }$ can be represented as a matrix $\\mathbf { E } _ { s _ { t } } \\in \\mathbb { R } ^ { | \\mathcal { E } _ { s _ { t } } | \\times 2 d _ { F } }$ , where each row represents an edge. The probability distribution over all the edges can be represented as ",
+        "bbox": [
+            173,
+            393,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4914fde5fc6ab3b201323f24fa7d0526840560cb9710865a784fca091fd27366.jpg",
+        "text": "$$\np _ { e d g e } ( \\cdot | s _ { t } ) = s o f t m a x ( M L P ( \\mathbf { E } _ { s _ { t } } | \\theta _ { e d g e } ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            541,
+            645,
+            559
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where we use $M L P ( \\cdot | \\theta _ { e d g e } )$ to denote a Multilayer Perceptron that maps $\\mathbf { E } _ { s _ { t } } \\in \\mathbb { R } ^ { | \\mathcal { E } _ { s _ { t } } | \\times 2 d _ { F } }$ to a vector in $\\mathbb { R } ^ { | \\mathcal { E } _ { s _ { t } } | }$ , which, after going through the softmax layer, represents the probability of choosing each edge. Let $e _ { t } = ( v _ { e _ { t 1 } } , v _ { e _ { t 2 } } )$ denote the edge sampled according to eq. equation 6. To decide which node is going to be the first node, we estimate the probability distribution over these two nodes as ",
+        "bbox": [
+            173,
+            564,
+            825,
+            637
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fa29bd03c9bd296fa4621ed3f168ef934cd3593834a823283ce00e5c48b40ea7.jpg",
+        "text": "$$\np _ { f i r } ( \\cdot | e _ { t } , s _ { t } ) = s o f t m a x ( M L P ( [ \\mathbf { v } _ { e _ { t 1 } } , \\mathbf { v } _ { e _ { t 2 } } ] ^ { T } | \\theta _ { f i r } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            640,
+            676,
+            659
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { v } _ { e _ { t _ { i } } } = c o n c a t ( \\mathbf { e } _ { t } , \\mathbf { F } _ { s _ { t } } [ e _ { t { i } } , : ] ) \\in \\mathbb { R } ^ { 3 d _ { F } }$ for $i = 1 , 2$ . The first node can be sampled from the two nodes $v _ { e _ { t 1 } } , v _ { e _ { t 2 } }$ according to eq. equation 7. We then proceed to estimate the probability distribution $p ( \\cdot | v _ { f i r _ { t } } , e _ { t } , s _ { t } )$ . For any node $v _ { c } ~ \\in ~ { \\cal N } ^ { 2 } ( v _ { f i r _ { t } } ) / { \\cal N } ^ { 1 } ( v _ { f i r _ { t } } )$ , we use $\\begin{array} { r l } { \\hat { \\mathbf { v } } _ { c } } & { { } = } \\end{array}$ $c o n c a t ( \\mathbf { v } _ { e _ { t 1 } } , \\mathbf { F } _ { s _ { t } } [ c , : ] )$ to represent it. The representations for all the nodes in $N ^ { 2 } \\dot { ( } v _ { f i r _ { t } } ) / N ^ { 1 } ( v _ { f i r _ { t } } )$ can be represented by a matrix $\\hat { \\bf V } _ { s _ { t } } \\in \\mathbb { R } ^ { | N ^ { 2 } ( v _ { f i r _ { t } } ) / N ^ { 1 } ( v _ { f i r _ { t } } ) | \\times 4 d _ { F } }$ with each row representing a node. The probability distribution of choosing the third node over all the candidate nodes can be modeled as: ",
+        "bbox": [
+            173,
+            662,
+            825,
+            770
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33bebec27bf3518a18bdbb45957e4ec465fad8fc0cd22c9eafac946499cca7d8.jpg",
+        "text": "$$\np _ { t h i } ( \\cdot | v _ { f i r _ { t } } , e _ { t } , s _ { t } ) = s o f t m a x ( M L P ( \\hat { \\mathbf { V } } _ { s _ { t } } | \\theta _ { t h i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            772,
+            666,
+            791
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The third node $v _ { t h i _ { t } }$ can be sampled from the set of candidate nodes $N ^ { 2 } ( v _ { f i r _ { t } } ) / N ^ { 1 } ( v _ { f i r _ { t } } )$ according to the probability distribution in eq equation 8. An action $a _ { t }$ can be generated by sequentially estimating and sampling from the probability distributions in eq. equation 6, equation 7 and equation 8. ",
+        "bbox": [
+            173,
+            796,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.4 PROPOSED FRAMEWORK - REWATT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            462,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "With the rewiring and the policy network defined above, our overall framework can be summarized as follows. With State $s _ { t }$ , the Attacker uses GCN to learn node and edge embeddings, which are used as input to Policy Networks to make decision about the next action. Once the new action is sampled from the policy network, rewiring is performed on $s _ { t }$ and we arrive in the new state $s _ { t + 1 }$ . We query the black-box classifier to get the prediction $f ( S _ { t + 1 } )$ , which is compared with $f ( s _ { 1 } )$ to get reward. Policy gradient (Sutton & Barto, 2018) is adopted to learn the policies by maximizing the rewards. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            194,
+            316,
+            210
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct experiments to evaluate the performance of the proposed framework ReWatt. We also carry out a study to analyze how the trained attacker works. Some empirical investigation on the advancements of the rewiring operation can be found in Appendix C. ",
+        "bbox": [
+            176,
+            226,
+            825,
+            267
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.1 ATTACK PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            286,
+            383,
+            300
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "To demonstrate the effectiveness of ReWatt, we conduct experiments on three widely used social network data sets (Kersting et al., 2016) for graph classification, i.e., REDDIT-MULTI-12K, REDDITMULTI-5K and IMDB-MULTI (Yanardag & Vishwanathan, 2015). The statistics can be found in Appendix D. Note that the re-wiring operation (as well as the other operations) may lead to abnormal structure of some kinds of graphs, which can make the graphs invalid, especially for chemical molecules. So in this paper, We avoid chemical related datasets but only use social networks datasets. In the social domain, if the changes are subtle, it is most likely that we will not we will not introduce abnormal structures. Meanwhile, it is straightforward to extend our framework to datsets from the other domains if we have expertise in them. For example, if we know what structures are abnormal, we can use such knowledge to constraint the the state space of the RL framework. We leave it as one future work. ",
+        "bbox": [
+            174,
+            311,
+            825,
+            464
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this work, the classifier we target to attack is the GCN-based classifier as introduced in Section 2. We set the number of layers to 3. We need to train the classifier using a fraction of the data and then treat the classifier as a black box to be attacked. We then use part of the remaining data to train the attacker and use the rest of the data to test the performance of the attacker. Thus, for each data set, we split it into three parts with the ratio of $a \\% : b \\% : c \\%$ , where $a \\%$ of the data set is used to train the classifier, $b \\%$ of the data set is used to train the attacker and the remaining $c \\%$ of the data set is used to test the performance of the attacker. For the REDDIT-MULTI-12K and REDDIT-MULTI5K data sets, we set $a = 9 0$ , $b = 8$ and $c = 2$ . As the size of the IMDB-MULTI data set is quite small, to have enough data for testing, we set $a = 5 0$ , $b = 3 0$ and $c = 2 0$ . ",
+        "bbox": [
+            174,
+            470,
+            825,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare the attacking performance of the proposed framework with the RL-S2V proposed in (Dai et al., 2018), random selection method and some variants of our proposed framework. We briefly describe these baselines: 1) RL-S2V is a reinforcement learning based attack framework (Dai et al., 2018), which allows adding and deleting edges to the graph with a fixed budget for all the graphs; 2) Random denotes an attacker that performs the proposed rewiring operations randomly; 3) Random-s is also based on random rewiring. Note that ReWatt can terminate before using all the budget. We record the actual number of rewiring actions made in our method and only allow the Random-s to take exactly the same number of rewiring actions as ReWatt; 4) ReWatt-n denotes a variant of the ReWatt, where the negative reward is fixed to $- 0 . 5$ for all the graphs in the testing set; and 5) ReWatt-a is a variant of ReWatt, where we allow any nodes in the graph to be the third node $v _ { t h i _ { t } }$ instead of only 2-hop neighbors. ",
+        "bbox": [
+            173,
+            603,
+            825,
+            756
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As RL-S2V only allows a fixed budget for the all the graphs, when comparing to it, for ReWatt, we also fix the number of proposed rewiring operations to a fixed number $K$ for all the graphs. Note that a single proposed rewiring operation involves two edges, thus, for a fair comparison, we allow the RL-S2V to take $2 K$ actions (adding/deleting edges). We set $K = 1 , 2 , 3$ in the experiments. To compare with the random selection method and the variants of ReWatt, we use flexible budget, more specially, we allow at most $\\boldsymbol { p } \\cdot \\left| \\mathcal { E } _ { i } \\right|$ proposed rewiring operations for graph $G _ { i }$ . Here, $p$ is a fixed percentage and we set it to $p = 1 \\%$ , $2 \\%$ , $3 \\%$ in our experiments. We use the success rate as measure to evaluate the performance of the attacker. A graph is said to be successfully attacked if its label is changed when it is modified within the given budget. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            888
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The results are shown in Table 1. From the table, we can make the following observations: 1) Compared to RL-S2V, ReWatt can perform more effective attacks. Especially, in the IMDB-MULTI data set, where ReWatt outperforms the RL-S2V with a large margin; 2) ReWatt outperforms the Random method as expected. Especially, ReWatt is much more effective than Random-s which performs exactly the same number of proposed rewiring operations ReWatt. This also indicates that the Random method uses more rewiring operations for successful attacking than ReWatt; 3) The variant ReWatt-a outperforms ReWatt, which means if we do not constraint the rewiring operation to 2-hop neighbors, the performance of ReWatt can be further improved. However, as we discussed in earlier sections, this may lead to more “noticeable” changes of the graph structure; and 4) ReWattn performs worse than our ReWatt, which shows the advancement of using a flexible reward design. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/961fb3a6fe4a25be6c63a5bd9a23bc30f6e86b938b6ee04c3a8b43f635bc4c89.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Performance comparison in terms of success rate "
+        ],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">REDDIT-MULTI-12K</td><td colspan=\"3\">REDDIT-MULTI-5K</td><td colspan=\"3\">IMDB-MULTI</td></tr><tr><td>K</td><td>1</td><td>2</td><td>3</td><td>1</td><td>2</td><td>3</td><td>1</td><td>2</td><td>3</td></tr><tr><td>ReWatt</td><td>14.4%</td><td>21.6%</td><td>23.4%</td><td>8.99%</td><td>16.9%</td><td>18.0%</td><td>23.0%</td><td>23.3%</td><td>23.3%</td></tr><tr><td>RL-S2V</td><td>9.46%</td><td>18.5%</td><td>21.1%</td><td>4.49%</td><td>16.9%</td><td>18.0%</td><td>2.00%</td><td>6.00%</td><td>3.33%</td></tr><tr><td>P</td><td>1%</td><td>2%</td><td>3%</td><td>1%</td><td>2%</td><td>3%</td><td>1%</td><td>2%</td><td>3%</td></tr><tr><td>ReWatt</td><td>25.2%</td><td>32.9%</td><td>38.7%</td><td>11.2%</td><td>20.2%</td><td>27.0%</td><td>23.0%</td><td>23.0%</td><td>23.3%</td></tr><tr><td>ReWatt-a</td><td>26.1%</td><td>35.1%</td><td>42.8%</td><td>5.60%</td><td>21.3%</td><td>30.3%</td><td>24.3%</td><td>25.0%</td><td>25.6%</td></tr><tr><td>ReWatt-n</td><td>17.6%</td><td>25.7%</td><td>31.1%</td><td>5.60%</td><td>14.6%</td><td>19.1%</td><td>21.3%</td><td>21.3%</td><td>21.6%</td></tr><tr><td>random</td><td>10.3%</td><td>15.7%</td><td>21.6%</td><td>3.30%</td><td>12.4%</td><td>16.9%</td><td>1.33%</td><td>1.33%</td><td>1.66%</td></tr><tr><td>random-s</td><td>6.30%</td><td>6.70%</td><td>9.45%</td><td>5.60%</td><td>6.74%</td><td>11.0%</td><td>1.00%</td><td>1.33%</td><td>1.66%</td></tr></table>",
+        "bbox": [
+            176,
+            93,
+            818,
+            248
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            289,
+            825,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5.2 ATTACKER ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            417,
+            364,
+            433
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we carry out experiments to analyze how ReWatt’s change in graph structure affects the graph representation u calculated by eq. equation 2 and the logits $\\mathbf { P }$ (the output immediately after the softmax layer of the classifier). For convenience, we denote the original graph as $G ^ { o }$ and the attacked graph as $G ^ { a }$ in this section. Correspondingly, the graph representation and logits for the original (attacked) graph are denoted as $\\mathbf { u } ^ { o }$ $( \\mathbf { u } ^ { a } )$ and $\\mathbf { P } ^ { o }$ $( \\mathbf { P } ^ { a } )$ , respectively. To measure the difference in graph representation, we used the relative difference in terms of 2-norm defined as $\\begin{array} { r } { R C ( \\mathbf { u } ^ { o } , \\mathbf { u } ^ { a } ) = \\frac { \\| \\mathbf { \\bar { u } } ^ { a } - \\mathbf { \\bar { u } } ^ { o } \\| _ { 2 } } { \\| \\mathbf { u } ^ { o } \\| _ { 2 } } } \\end{array}$ kua−uok2kuok . The logits denote the probability distribution that the given graph belongs to each of the classes. Thus, we use the KL-divergence Kullback (1997) to measure the difference between the logits of the original and attacked graphs $K L ( \\mathbf { P } ^ { o } , \\mathbf { P } ^ { a } ) = \\sum _ { i = 1 } ^ { C } \\mathbf { P } ^ { o } [ i ] \\log \\left( \\frac { \\mathbf { P } ^ { o } [ i ] } { \\mathbf { P } ^ { a } [ i ] } \\right)$ , where $C$ is the number of classes in the data set and $\\mathbf { P } [ i ]$ denotes the logit for the $i$ -th class. ",
+        "bbox": [
+            173,
+            444,
+            825,
+            604
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We perform the experiments on the REDDIT-MULTI-12K data set under the setting of allowing at most $3 \\% \\cdot | \\mathcal { E } |$ proposed rewiring operations. The results for the graph representation and logits are shown in Figure 1 and Figure 2, respectively. The graphs in the testing set are separated in two groups, one group contains all the graphs successfully attacked by ReWatt (shown in Figure 1a and Figure 2a), and the other one contains those survived from ReWatt’s attack (shown in Figure 1b and Figure 2b). Note that, for comparison, we also include the results of Random-s on these two groups of graphs. In these figures, a single point represents a testing graph, the $\\mathbf { X }$ -axis is the ratio $\\frac { M } { | { \\mathcal { E } } | }$ , where $M$ is the number of rewiring operations ReWatt used before the attacking process terminating. Note that $M$ can be smaller than the budget as the process terminates once the attack successes. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "As we can observe from the figures, compared with the Random-s, ReWatt can make more changes to both the graph representation and logits, using exactly the same number of proposed rewiring operations. Comparing Figure 1a with Figure 1b, we find that the perturbation generated by ReWatt affects the graph representation a lot even when it fails to attack the graph. This means our attack is perturbing the graph structure in a right way to fool the classifier, although it fails potentially due to the limited budget. Similar observation can be made when we compare Figure 2a with Figure 2b. ",
+        "bbox": [
+            174,
+            746,
+            825,
+            829
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            344,
+            866
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In recent years, adversarial attacks on deep learning models have attracted increasing attention in the area of computer vision. Many deep models are found to be easily fooled by adversarial samples, which are generated by adding deliberately designed unnoticeable perturbation to normal images (Szegedy et al., 2013; Goodfellow et al., 2014). More algorithms with different level access to the target classifier have been proposed, including white-box attack models, which have access to the gradients (Moosavi-Dezfooli et al., 2016; Kurakin et al., 2016; Carlini & Wagner, 2017) and black-box attack model, which have limited access to the target classifier (Chen et al., 2017; Cheng et al., 2018; Ilyas et al., 2018). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/c9820d2ee9a8b72c25a374571cf0a4885313b4c6d8b258ea20986b6a1f04a8d0.jpg",
+        "image_caption": [
+            "Figure 1: The change of graph representation after attack "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            104,
+            779,
+            256
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c77513a8e27a29031e226e0dd277311e53945083e1c4c97ae978cc38291e376.jpg",
+        "image_caption": [
+            "Figure 2: The change of logits after attack "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            297,
+            779,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            502,
+            825,
+            571
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Most of the aforementioned works are focusing in the computer vision domain, where the data sample can be represented in the continues space. Few attention has been payed into the discrete data structure such as graphs. Graph Neural Networks have been shown to bring impressive advancements to many different graph related tasks such as node classification and graph classification. Recent researches show that the graph neural networks are also venerable to adversarial attacks. (Zugner et al., 2018) proposed a greedy algorithm to perform adversarial attack to node classifi-¨ cation task. Their algorithm tries to change the label of a target node by modifying both the graph structure and node features. (Dai et al., 2018) proposed a deep reinforcement learning based attacker to attack both the node classification and the graph classification task. (Zugner & G ¨ unnemann, ¨ 2019) designed an algorithm to impair the overall performance of node classification based on meta learning. All the three mentioned methods modify the graph structure by adding or deleting edges. A more recent work Wang et al. (2018) on attacking node classifications proposed to modify the graph structure by adding fake nodes. In this work, we propose to modify the graph structure using rewiring, which is shown to make less noticeable changes to the graph structure. ",
+        "bbox": [
+            174,
+            579,
+            825,
+            773
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            803,
+            318,
+            819
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed a graph rewiring operation, which affect the graph structure in a less noticeable way than adding/deleting edges. The rewiring operation preserves some basic graph properties such as number of nodes and number of edges. We then designed an attacker ReWatt based on the rewiring operations using reinforcement learning. Experiments in 3 real world data sets show the effectiveness of the proposed framework. Analysis on how the graph representation and logits change while the graph being attacked provide us with some insights of the attacker. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Joan Bruna, Wojciech Zaremba, Arthur Szlam, and Yann LeCun. Spectral networks and locally connected networks on graphs. arXiv preprint arXiv:1312.6203, 2013. ",
+        "bbox": [
+            173,
+            125,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicholas Carlini and David Wagner. Towards evaluating the robustness of neural networks. In 2017 IEEE Symposium on Security and Privacy $( S P )$ , pp. 39–57. IEEE, 2017. ",
+        "bbox": [
+            173,
+            161,
+            823,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hau Chan and Leman Akoglu. Optimizing network robustness by edge rewiring: a general framework. Data Mining and Knowledge Discovery, 30(5):1395–1425, 2016. ",
+        "bbox": [
+            173,
+            199,
+            823,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Pin-Yu Chen, Huan Zhang, Yash Sharma, Jinfeng Yi, and Cho-Jui Hsieh. Zoo: Zeroth order optimization based black-box attacks to deep neural networks without training substitute models. In Proceedings of the 10th ACM Workshop on Artificial Intelligence and Security, pp. 15–26. ACM, 2017. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            291
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Minhao Cheng, Thong Le, Pin-Yu Chen, Jinfeng Yi, Huan Zhang, and Cho-Jui Hsieh. Queryefficient hard-label black-box attack: An optimization-based approach. arXiv preprint arXiv:1807.04457, 2018. ",
+        "bbox": [
+            171,
+            300,
+            823,
+            343
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Hanjun Dai, Hui Li, Tian Tian, Xin Huang, Lin Wang, Jun Zhu, and Le Song. Adversarial attack on graph structured data. In International Conference on Machine Learning, pp. 1123–1132, 2018. ",
+        "bbox": [
+            173,
+            351,
+            823,
+            381
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael Defferrard, Xavier Bresson, and Pierre Vandergheynst. Convolutional neural networks on ¨ graphs with fast localized spectral filtering. In Advances in neural information processing systems, pp. 3844–3852, 2016. ",
+        "bbox": [
+            171,
+            387,
+            823,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wendy Ellens, FM Spieksma, P Van Mieghem, A Jamakovic, and RE Kooij. Effective graph resistance. Linear algebra and its applications, 435(10):2491–2506, 2011. ",
+        "bbox": [
+            173,
+            438,
+            823,
+            468
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Miroslav Fiedler. Algebraic connectivity of graphs. Czechoslovak mathematical journal, 23(2): 298–305, 1973. ",
+        "bbox": [
+            173,
+            476,
+            823,
+            505
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Arpita Ghosh and Stephen Boyd. Growing well-connected graphs. In Proceedings of the 45th IEEE Conference on Decision and Control, pp. 6605–6611. IEEE, 2006. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            173,
+            549,
+            823,
+            579
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Will Hamilton, Zhitao Ying, and Jure Leskovec. Inductive representation learning on large graphs. In Advances in Neural Information Processing Systems, pp. 1024–1034, 2017. ",
+        "bbox": [
+            174,
+            585,
+            821,
+            616
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew Ilyas, Logan Engstrom, Anish Athalye, and Jessy Lin. Black-box adversarial attacks with limited queries and information. arXiv preprint arXiv:1804.08598, 2018. ",
+        "bbox": [
+            173,
+            623,
+            823,
+            652
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kristian Kersting, Nils M. Kriege, Christopher Morris, Petra Mutzel, and Marion Neumann. Benchmark data sets for graph kernels, 2016. URL http://graphkernels.cs.tu-dortmund. de. ",
+        "bbox": [
+            174,
+            660,
+            825,
+            702
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907, 2016. ",
+        "bbox": [
+            173,
+            710,
+            821,
+            741
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Solomon Kullback. Information theory and statistics. Courier Corporation, 1997. ",
+        "bbox": [
+            173,
+            747,
+            712,
+            763
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial examples in the physical world. arXiv preprint arXiv:1607.02533, 2016. ",
+        "bbox": [
+            173,
+            770,
+            818,
+            800
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Benjamin A Miller, Mustafa C¸ amurcu, Alexander J Gomez, Kevin Chan, and Tina Eliassi-Rad. Improving robustness to attacks against vertex classification. 2019. ",
+        "bbox": [
+            173,
+            808,
+            821,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bojan Mohar, Y Alavi, G Chartrand, and OR Oellermann. The laplacian spectrum of graphs. Graph theory, combinatorics, and applications, 2(871-898):12, 1991. ",
+        "bbox": [
+            173,
+            843,
+            823,
+            875
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Seyed-Mohsen Moosavi-Dezfooli, Alhussein Fawzi, and Pascal Frossard. Deepfool: a simple and accurate method to fool deep neural networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 2574–2582, 2016. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aliaksei Sandryhaila and Jose MF Moura. Discrete signal processing on graphs: Frequency analysis. IEEE Transactions on Signal Processing, 62(12):3042–3054, 2014. ",
+        "bbox": [
+            169,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David I Shuman, Sunil K Narang, Pascal Frossard, Antonio Ortega, and Pierre Vandergheynst. The emerging field of signal processing on graphs: Extending high-dimensional data analysis to networks and other irregular domains. arXiv preprint arXiv:1211.0053, 2012. ",
+        "bbox": [
+            176,
+            140,
+            823,
+            183
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Gilbert W Stewart. Matrix perturbation theory. 1990. ",
+        "bbox": [
+            176,
+            190,
+            524,
+            205
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction. MIT press, 2018. ",
+        "bbox": [
+            173,
+            213,
+            821,
+            228
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Sydney, Caterina Scoglio, and Don Gruenbacher. Optimizing algebraic connectivity by edge rewiring. Applied Mathematics and computation, 219(10):5465–5479, 2013. ",
+        "bbox": [
+            174,
+            236,
+            823,
+            265
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian Goodfellow, and Rob Fergus. Intriguing properties of neural networks. arXiv preprint arXiv:1312.6199, 2013. ",
+        "bbox": [
+            174,
+            272,
+            823,
+            301
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xiaoyun Wang, Joe Eaton, Cho-Jui Hsieh, and Felix Wu. Attack graph convolutional networks by adding fake nodes. arXiv preprint arXiv:1810.10751, 2018. ",
+        "bbox": [
+            173,
+            309,
+            823,
+            338
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In Proceedings of the 21th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 1365–1374. ACM, 2015. ",
+        "bbox": [
+            174,
+            345,
+            825,
+            388
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Rex Ying, Jiaxuan You, Christopher Morris, Xiang Ren, William L Hamilton, and Jure Leskovec. Hierarchical graph representation learning withdifferentiable pooling. arXiv preprint arXiv:1806.08804, 2018. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            439
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Muhan Zhang, Zhicheng Cui, Marion Neumann, and Yixin Chen. An end-to-end deep learning architecture for graph classification. In Thirty-Second AAAI Conference on Artificial Intelligence, 2018. ",
+        "bbox": [
+            174,
+            446,
+            825,
+            488
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marinka Zitnik, Rok Sosic, Marcus W. Feldman, and Jure Leskovec. Evolution of resilience in ˇ protein interactomes across the tree of life. Proceedings of the National Academy of Sciences, 116(10):4426–4433, 2019. ISSN 0027-8424. doi: 10.1073/pnas.1818013116. URL https: //www.pnas.org/content/116/10/4426. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Zugner, Amir Akbarnejad, and Stephan G ¨ unnemann. Adversarial attacks on neural networks ¨ for graph data. In Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 2847–2856. ACM, 2018. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            604
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel Zugner and Stephan G ¨ unnemann. Adversarial attacks on graph neural networks via meta ¨ learning. In International Conference on Learning Representations, 2019. URL https:// openreview.net/forum?id $\\underline { { \\underline { { \\mathbf { \\Pi } } } } } =$ Bylnx209YX. ",
+        "bbox": [
+            174,
+            612,
+            825,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A GRAPH LAPLACIAN BASED MEASURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            679,
+            537,
+            695
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Many important graph properties are based on the eigenvalues of the Laplacian matrix of a graph (Chan & Akoglu, 2016). Here we list few: ",
+        "bbox": [
+            174,
+            710,
+            823,
+            738
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• Algebraic Connectivity The algebraic connectivity of a graph $G$ is the second-smallest eigenvalue of its Laplacian matrix (Fiedler, 1973). Note that we only consider connected graphs in this work, so it is always larger than 0. The larger the algebraic connectivity is, the more difficult it is to separate the graph into components (i.e., more edges need to be removed). The algebraic connectivity has previously been applied to measure network robustness Sydney et al. (2013). ",
+        "bbox": [
+            174,
+            750,
+            825,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "• Effective Graph Resistance The effective graph resistance is a graph measure derived from the field of electric circuit analysis, where it is defined as the summation of effective resistance over all node pairs (Ellens et al., 2011). The effective graph resistance can be represented using the eigenvalues of Laplacian matrix as follows (Ellens et al., 2011) ",
+        "bbox": [
+            174,
+            823,
+            825,
+            878
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b2315e9054b47e134a09bfbec09df276d9150dd6fb560d4c1d954fea65cacd39.jpg",
+        "text": "$$\nR _ { e } = | \\mathcal { V } | \\cdot \\sum _ { i = 2 } ^ { | \\mathcal { V } | } \\lambda _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            446,
+            883,
+            568,
+            928
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "By Corollary 2, we can represent the change of the algebraic connectivity $\\lambda _ { 2 }$ as: ",
+        "bbox": [
+            173,
+            103,
+            697,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/050449ac688ffafc0b09a06d55cd61b5eab28e007c45331bd2ccd19a3a9c0f42.jpg",
+        "text": "$$\n\\Delta \\lambda _ { 2 } = ( 2 { \\bf x } _ { 2 } [ f i r ] - { \\bf x } _ { 2 } [ t h i ] - { \\bf x } _ { 2 } [ s e c ] ) ( { \\bf x } _ { 2 } [ s e c ] - { \\bf x } _ { 2 } [ t h i ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            125,
+            694,
+            142
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "According to the above discussion, $\\Delta \\lambda _ { 2 }$ is expected to be smaller for the operation of rewiring to 2-hop neighbor. Thus, the rewiring to 2-hop neighbor operation is expected to perturb the algebraic connectivity less compared with adding an edge between two nodes that are far away from each other. A similar argument can be built for effective graph resistance. ",
+        "bbox": [
+            173,
+            148,
+            825,
+            205
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "B PROOF OF COLLARY 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            224,
+            393,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Corollary 2. For a given graph $G$ with Laplacian matrix $\\mathbf { L }$ , one proposed rewiring operation $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ affects the eigen-value $\\lambda _ { i }$ by $\\Delta \\lambda _ { i }$ , for $i = 1 , \\ldots , | \\nu |$ , where ",
+        "bbox": [
+            173,
+            256,
+            825,
+            286
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6b36d5745f96b9135381a0e729da7af20db1c530cfc0b4ec507f7bc561a8707a.jpg",
+        "text": "$$\n\\Delta { \\lambda } _ { i } = ( 2 { \\bf { x } } _ { i } [ f i r ] - { \\bf { x } } _ { i } [ t h i ] - { \\bf { x } } _ { i } [ s e c ] ) ( { \\bf { x } } _ { i } [ s e c ] - { \\bf { x } } _ { i } [ t h i ] )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            292,
+            687,
+            310
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { x } _ { i } [ i n d e x ]$ denotes the index-th value of the eigenvector $\\mathbf { x } _ { i }$ ",
+        "bbox": [
+            173,
+            315,
+            607,
+            332
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Proof. Let $\\Delta \\mathbf { L }$ denotes the change in the Laplacian matrix after applying the rewiring operation $( v _ { f i r } , v _ { s e c } , v _ { t h i } )$ to graph $G$ . Then we have $\\Delta { \\bf L } [ f i r , s e c ] = \\Delta { \\bf L } [ s e c , f i r ] = 1$ , $\\Delta \\mathbf { L } [ f i r , t h i ] =$ $\\Delta { \\bf L } [ t h i , f i r ] = - 1$ , $\\Delta \\mathbf { L } [ s e c , s e c ] = - 1$ , $\\Delta \\mathbf { L } [ t h i , t h i ] = 1$ and 0 elsewhere. Thus ",
+        "bbox": [
+            176,
+            345,
+            823,
+            390
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d9527de1141d5f416e7fd3616aacbd3d1aa62ec0169e869996e119c6a27a4398.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\Delta \\lambda _ { i } = \\mathbf { x } _ { i } ^ { T } \\Delta \\mathbf { L } \\mathbf { x } _ { i } } \\\\ & { \\quad \\quad = 2 \\mathbf { x } _ { i } [ f i r ] \\mathbf { x } _ { i } [ s e c ] - \\mathbf { x } _ { i } [ s e c ] ^ { 2 } + \\mathbf { x } _ { i } [ t h i ] ^ { 2 } - 2 \\mathbf { x } _ { i } [ f i r ] \\mathbf { x } _ { i } [ t h i ] } \\\\ & { \\quad = \\mathbf { x } _ { i } [ t h i ] ^ { 2 } - \\mathbf { x } _ { i } [ s e c ] ^ { 2 } + 2 \\mathbf { x } _ { i } [ f i r ] ( \\mathbf { x } _ { i } [ s e c ] - \\mathbf { x } _ { i } [ t h i ] ) } \\\\ & { \\quad = ( 2 \\mathbf { x } _ { i } [ f i r ] - \\mathbf { x } _ { i } [ t h i ] - \\mathbf { x } _ { i } [ s e c ] ) ( \\mathbf { x } _ { i } [ s e c ] - \\mathbf { x } _ { i } [ t h i ] ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            285,
+            395,
+            710,
+            474
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "which completes the proof. ",
+        "bbox": [
+            174,
+            479,
+            352,
+            493
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C EMPIRICAL INVESTIGATION OF THE REWIRING OPERATION",
+        "text_level": 1,
+        "bbox": [
+            176,
+            513,
+            704,
+            531
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct experiments to empirically show the advancements of the proposed rewiring operator compared with the adding/deleting edge operator. We compare them from two perspectives: 1) connectivity after the attack and 2) change in eigenvalues after the attack. The experiments are carried out on the REDDIT-MULTI-12K dataset. On each of the graph successfully attacked by ReWatt, we perform exactly the same number of deleting/adding edge operator on it. For connectivity, the average number of components in the clean graphs is 2.6, this number becomes 3.02 after the rewiring attack while it becomes 5.2 after the deleting/adding edges attack. On the other hand, only $2 0 \\%$ of the graphs get more disconnected (having more components) after ReWattattack than the original ones, while $8 7 \\%$ of the graphs get more disconnected after the adding/deleting edges attack. Clearly, the rewiring operator is less likely to disconnect the graph. The comparison of the change in eigenvalues is shown in Figure 3, where we compare the change in different eigenvalues of the graphs after these two attacks. Specifically, we first compute the average relative change in the $i$ -th eigenvalue after both attacks as follows: ",
+        "bbox": [
+            173,
+            545,
+            826,
+            727
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "equation",
+        "img_path": "images/247871e78388c6f36bca3b3ca76cc2597fb9ac7fa590a472bcc7433ca2587e28.jpg",
+        "text": "$$\nr _ { \\lambda _ { i } } = \\frac { | \\lambda _ { i } ^ { o r i } - \\lambda _ { i } ^ { a t t a c k } | } { \\lambda _ { i } ^ { o r i } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            733,
+            576,
+            768
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda _ { i } ^ { o r i }$ denotes the $i$ -th eigenvalue of the clean graph while $\\lambda _ { i } ^ { a t t a c k }$ denotes the $i$ -th eigenvalue of the attacked graph. We then take the average of the above value over all the succeeded graphs, which we denoted as $\\bar { r } _ { \\lambda _ { i } }$ . Specially, we use $\\bar { r } _ { \\lambda _ { i } } ^ { r e }$ to denote the average change ratio after $R e W a t t$ while using r¯d/λ to denote the average change ratio after deleting/adding edge attack. To compare the these two attacks, we calculate r¯d/aλ / $\\bar { r } _ { \\lambda _ { i } } ^ { d / a } / \\bar { r } _ { \\lambda _ { i } } ^ { r e }$ and the results are shown in Figure 3. The results show that in most of the cases, the deleting/adding edges attack makes much more changes to the eigenvalues as the value r¯d/aλi / $\\bar { r } _ { \\lambda _ { i } } ^ { d / a } / \\bar { r } _ { \\lambda _ { i } } ^ { r e }$ is way larger than 1. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            891
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "By conducting these two experiments, we empirically conclude that the proposed re-wiring operator makes more subtle changes to graphs than existing methods. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/90368341caeeddcf829db276aed7c06c67173ec29cea181419e67dddb542fdda.jpg",
+        "image_caption": [
+            "Figure 3: Comparison in the change of eigenvalues "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            272,
+            106,
+            725,
+            324
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D STATISTICS OF THE DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            381,
+            462,
+            397
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The statistics of the datasets are given in Table 2. In this table, #nodes denotes the average number of nodes over all graphs and #edges denotes the average number of edges over all graphs. ACC denotes the mean of Average Clustering Coefficient (ACC) over all graphs. GCC denotes the mean of Global Clustering Coefficient (GCC) over all graphs. ",
+        "bbox": [
+            174,
+            411,
+            826,
+            469
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/d9ee85702edc3f9dd39aafc4eb0e9c1de9f4aebd67e7069fde884062060b5b36.jpg",
+        "table_caption": [
+            "Table 2: Statistics of the data sets "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>#graphs</td><td rowspan=1 colspan=1>#labels</td><td rowspan=1 colspan=1>#nodes</td><td rowspan=1 colspan=1>#edges</td><td rowspan=1 colspan=1>ACC</td><td rowspan=1 colspan=1>GCC</td></tr><tr><td rowspan=1 colspan=1>REDDIT-MULTI-12K</td><td rowspan=1 colspan=1>11,929</td><td rowspan=1 colspan=1>12</td><td rowspan=1 colspan=1>391.41</td><td rowspan=1 colspan=1>456.89</td><td rowspan=1 colspan=1>0.0331</td><td rowspan=1 colspan=1>0.0087</td></tr><tr><td rowspan=1 colspan=1>REDDIT-MULTI-5K</td><td rowspan=1 colspan=1>4,999</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>508.52</td><td rowspan=1 colspan=1>594.87</td><td rowspan=1 colspan=1>0.0268</td><td rowspan=1 colspan=1>0.0038</td></tr><tr><td rowspan=1 colspan=1>IMDB-MULTI</td><td rowspan=1 colspan=1>1,500</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>13</td><td rowspan=1 colspan=1>65.94</td><td rowspan=1 colspan=1>0.968</td><td rowspan=1 colspan=1>0.8955</td></tr></table>",
+        "bbox": [
+            214,
+            481,
+            781,
+            541
+        ],
+        "page_idx": 11
+    }
+]

parse/train/BJg7x1HFvB/BJg7x1HFvB.md

@@ -0,0 +1,282 @@
+# WELL-READ STUDENTS LEARN BETTER: ON THE IMPORTANCE OF PRE-TRAINING COMPACT MODELS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent developments in natural language representations have been accompanied by large and expensive models that leverage vast amounts of general-domain text through self-supervised pre-training. Due to the cost of applying such models to down-stream tasks, several model compression techniques on pre-trained language representations have been proposed (Sun et al., 2019a; Sanh, 2019). However, surprisingly, the simple baseline of just pre-training and fine-tuning compact models has been overlooked. In this paper, we first show that pre-training remains important in the context of smaller architectures, and fine-tuning pre-trained compact models can be competitive to more elaborate methods proposed in concurrent work. Starting with pre-trained compact models, we then explore transferring task knowledge from large fine-tuned models through standard knowledge distillation. The resulting simple, yet effective and general algorithm, Pre-trained Distillation, brings further improvements. Through extensive experiments, we more generally explore the interaction between pre-training and distillation under two variables that have been under-studied: model size and properties of unlabeled task data. One surprising observation is that they have a compound effect even when sequentially applied on the same data. To accelerate future research, we will make our 24 pre-trained miniature BERT models publicly available.
+
+# 1 INTRODUCTION
+
+Self-supervised learning on a general-domain text corpus followed by end-task learning is the twostaged training approach that enabled deep-and-wide Transformer-based networks (Vaswani et al., 2017) to advance language understanding (Devlin et al., 2018; Yang et al., 2019b; Sun et al., 2019b; Liu et al., 2019). However, state-of-the-art models have hundreds of millions of parameters, incurring a high computational cost. Our goal is to realize their gains under a restricted memory and latency budget. We seek a training method that is well-performing, general and simple and can leverage additional resources such as unlabeled task data.
+
+Before considering compression techniques, we start with the following research question: Could we directly train small models using the same two-staged approach? In other words, we explore the idea of applying language model (LM) pre-training and task fine-tuning to compact architectures directly. This simple baseline has so far been overlooked by the NLP community, potentially based on an underlying assumption that the limited capacity of compact models is capitalized better when focusing on the end task rather than a general language model objective. Concurrent work to ours proposes variations of the standard pre-training+fine-tuning procedure, but with limited generality (Sun et al., 2019a; Sanh, 2019). We make the surprising finding that pre-training+fine-tuning in its original formulation is a competitive method for building compact models.
+
+For further gains, we additionally leverage knowledge distillation (Hinton et al., 2015), the standard technique for model compression. A compact student is trained to recover the predictions of a highly accurate teacher. In addition to the posited regularization effect of these soft labels (Hinton et al., 2015), distillation provides a means of producing pseudo-labels for unlabeled data. By regarding LM pre-training of compact models as a student initialization strategy, we can take advantage of both methods. The resulting algorithm is a sequence of three standard training operations: masked LM (MLM) pre-training (Devlin et al., 2018), task-specific distillation, and optional fine-tuning. From here on, we will refer to it as Pre-trained Distillation (PD) (Figure 1). As we will show in
+
+![](images/f20fb237743e755cb02fd23f0f3575d24a1fa24ce671852eb43c326c4d807d41.jpg)  
+Figure 1: Pre-trained Distillation
+
+![](images/bbbc5cbdd7d1bfb03160815edb3fa08d2dcb5e389bcc8253d8e21feeb0f1551d.jpg)
+
+Section 6.2, PD outperforms the pre-training $^ +$ fine-tuning (PF) baseline, especially in the presence of a large transfer set for distillation.
+
+In a controlled study following data and model architecture settings in concurrent work (Section 4), we show that Pre-trained Distillation outperforms or is competitive with more elaborate approaches which use either more sophisticated distillation of task knowledge (Sun et al., 2019a) or more sophisticated pre-training from unlabeled text (Sanh, 2019). The former distill task knowledge from intermediate teacher activations, starting with a heuristically initialized student. The latter fine-tune a compact model that is pre-trained on unlabeled text with the help of a larger LM teacher.
+
+One of the most noteworthy contributions of our paper are the extensive experiments that examine how Pre-trained Distillation and its baselines perform under various conditions. We investigate two axes that have been under-studied in previous work: model size and amount/quality of unlabeled data. While experimenting with 24 models of various sizes ( $4 \mathrm m$ to $1 1 0 \mathrm { m }$ parameters) and depth/width trade-offs, we observe that pre-trained students can leverage depth much better than width; in contrast, this property is not visible for randomly-initialized models. For the second axis, we vary the amount of unlabeled data, as well as its similarity to the labeled set. Interestingly, Pretrained Distillation is more robust to these variations in the transfer set than standard distillation.
+
+Finally, in order to gain insight into the interaction between LM pre-training and task-specific distillation, we sequentially apply these operations on the same dataset. In this experiment, chaining the two operations performs better than any one of them applied in isolation, despite the fact that a single dataset was used for both steps. This compounding effect is surprising, indicating that pre-training and distillation are learning complementary aspects of the data.
+
+Given the effectiveness of LM pre-training on compact architectures, we will make our 24 pretrained miniature BERT models publicly available in order to accelerate future research.
+
+# 2 PROBLEM STATEMENT
+
+Our high-level goal is to build accurate models which fit a given memory and latency budget. There are many aspects to explore: the parametric form of the compact model (architecture, number of parameters, trade-off between number of hidden layers and embedding size), the training data (size, distribution, presence or absence of labels, training objective), etc. Since an exhaustive search over this space is impractical, we fix the model architecture to bidirectional Transformers, known to be suitable for a wide range of NLP tasks (Vaswani et al., 2017; Devlin et al., 2018). The rest of this section elaborates on the training resources we assume to have at our disposal.
+
+The teacher is a highly accurate but large model for an end task, that does not meet the resource constraints. Prior work on distillation often makes use of an ensemble of networks (Hinton et al., 2015). For faster experimentation, we use a single teacher, without making a statement about the best architectural choice. In Section 4, the teacher is pre-trained BERTBASE fine-tuned on labeled end-task data. In Section 6, we use BERTLARGE instead.
+
+Students are compact models that satisfy resource constraints. Since model size qualifiers are relative (e.g., what is considered small in a data center can be impractically large on a mobile device),
+
+(a) Millions of parameters
+
+Table 1: Student models with various numbers of transformer layers $\mathbf { \Pi } ( \mathbf { L } )$ and hidden embedding sizes $\mathbf { \Pi } ( \mathbf { H } )$ . Latency is computed on Cloud TPUs with batch size 1 and sequence length 512. For readability, we focus on five models (underlined) for most figures: Tiny ( $_ { \mathrm { L } = 2 }$ , $\mathrm { H } { = } 1 2 \bar { 8 }$ ), Mini $\mathrm { L } { = } 4$ , $_ { \mathrm { H } = 2 5 6 }$ ), Small $\mathrm { L } { = } 4$ , $_ { \mathrm { H } = 5 1 2 }$ ), Medium $\mathrm { L } { = } 8$ , $_ { \mathrm { H } = 5 1 2 }$ ), and Base ( $_ { \mathrm { L } = 1 2 }$ , $_ { \mathrm { H } = 7 6 8 }$ ).   
+
+<table><tr><td></td><td>H=128</td><td>H=256</td><td>H=512</td><td>H=768</td></tr><tr><td>L=2</td><td>4.4</td><td>9.7</td><td>22.8</td><td>39.2</td></tr><tr><td>L=4</td><td>4.8</td><td>11.3</td><td>29.1</td><td>53.4</td></tr><tr><td>L=6</td><td>5.2</td><td>12.8</td><td>35.4</td><td>67.5</td></tr><tr><td>L=8</td><td>5.6</td><td>14.4</td><td>41.7</td><td>81.7</td></tr><tr><td>L=10</td><td>6.0</td><td>16.0</td><td>48.0</td><td>95.9</td></tr><tr><td>L=12</td><td>6.4</td><td>17.6</td><td>54.3</td><td>110.1</td></tr></table>
+
+<table><tr><td></td><td>H=128</td><td>H=256</td><td>H=512</td><td>H=768</td></tr><tr><td>L=2</td><td>65.24</td><td>31.25</td><td>14.44</td><td>7.46</td></tr><tr><td>L=4</td><td>32.37</td><td>15.96</td><td>7.27</td><td>3.75</td></tr><tr><td>L=6</td><td>21.87</td><td>10.67</td><td>4.85</td><td>2.50</td></tr><tr><td>L=8</td><td>16.42</td><td>8.01</td><td>3.64</td><td>1.88</td></tr><tr><td>L=10</td><td>13.05</td><td>6.37</td><td>2.90</td><td>1.50</td></tr><tr><td>L=12</td><td>11.02</td><td>5.35</td><td>2.43</td><td>1.25</td></tr></table>
+
+(b) Relative speedup wrt BERTLARGE on TPU v2
+
+we investigate an array of 24 model sizes, from our TransformerTINY ( $4 \mathrm m$ parameters) all the way up to TransformerBASE ( $1 1 0 \mathrm { m }$ parameters)1. The student model sizes and their relative speed-up compared to the BERTLARGE teacher can be found in Table 1. Interested readers can situate themselves on this spectrum based on their resource constraints. For readability, most plots show a selection of 5 models, but we verify that our conclusions hold for all 24.
+
+Labeled data $( \mathcal { D } _ { L } )$ is a set of $N$ training examples $\left\{ ( x _ { 1 } , y _ { 1 } ) , . . . , ( x _ { N } , y _ { N } ) \right\}$ , where $x _ { i }$ is an input and $y _ { i }$ is a label. For most NLP tasks, labeled sets are hard to produce and thus restricted in size.
+
+Unlabeled transfer data $( \mathcal { D } _ { T } )$ is a set of $M$ input examples of the form $\{ x _ { 1 } ^ { \prime } , . . . , x _ { M } ^ { \prime } \}$ sampled from a distribution that is similar to but possibly not identical to the input distribution of the labeled set. During distillation, the teacher transfers knowledge to the student by exposing its label predictions for instances $ { \boldsymbol { { x } } } _ { m } ^ { \prime }$ . $\mathcal { D } _ { T }$ can also include the input portion of labeled data $\mathcal { D } _ { L }$ instances. Due to the lack of true labels, such sets are generally easier to produce and consequently larger than labeled ones. Note, however, that task-relevant input text is not readily available for key tasks requiring paired texts such as natural language inference and question answering, as well as domain-specific dialog understanding. In addition, for deployed systems, input data distribution shifts over time and existing unlabeled data becomes stale (Kim et al., 2017).
+
+Unlabeled language model data $( \mathcal { D } _ { L M } )$ is a collection of natural language texts that enable unsupervised learning of text representations. We use it for unsupervised pre-training with a masked language model objective (Devlin et al., 2018). Because no labels are needed and strong domain similarity is not required, these corpora are often vast, containing thousands of millions of words.
+
+The distinction between the three types of datasets is strictly functional. Note they are not necessarily disjunct. For instance, the same corpus that forms the labeled data can also be part of the unlabeled transfer set, after its labels are discarded. Similarly, corpora that are included in the transfer set can also be used as unlabeled LM data.
+
+# 3 PRE-TRAINED DISTILLATION
+
+Pre-trained Distillation (PD) (Figure 1) is a general, yet simple algorithm for building compact models that can leverage all the resources enumerated in Section 2. It consists of a sequence of three standard training operations that can be applied to any choice of architecture:
+
+1. Pre-training on $\mathcal { D } _ { L M }$ . A compact model is trained with a masked LM objective (Devlin et al., 2018), capturing linguistic phenomena from a large corpus of natural language texts.   
+2. Distillation on $\mathcal { D } _ { T }$ . This well-read student is now prepared to take full advantage of the teacher expertise, and is trained on the soft labels (predictive distribution) produced by the teacher. As we will show in Section 6.2, randomly initialized distillation is constrained by the size and distribution of its unlabeled transfer set. However, the previous pre-training step mitigates to some extent the negative effects caused by an imperfect transfer set.   
+3. (Optional) fine-tuning on $\mathcal { D } _ { L }$ . This step makes the model robust to potential mismatches between the distribution of the transfer and labeled sets. We will refer to the two-step algorithm as PD, and to the three-step algorithm as PDF.
+
+Table 2: Training Strategies that build compact models by applying language model (LM) pretraining before knowledge distillation (KD). The first two rows apply distillation on task data. The third row applies distillation with an LM objective on general-domain data.   
+
+<table><tr><td>Model</td><td>Step 1 (DLm)</td><td>Step 2(Dr = DL)</td><td>Architecture-agnostic</td></tr><tr><td>PD (our work)</td><td>LM pre-training</td><td>KD</td><td>√</td></tr><tr><td>Sun et al. (2019a)</td><td>BERTBASE truncated</td><td>Patient-KD</td><td>X</td></tr><tr><td>Sanh (2019)</td><td>BERTBASE truncated + LM-KD</td><td>Fine-tuning</td><td>×</td></tr></table>
+
+<table><tr><td>Model</td><td></td><td>SST-2 (acc)</td><td>MRPC (f1/acc)</td><td>QQP (f1/acc)</td><td>MNLI (acc m/mm)</td><td>QNLI (acc)</td><td>RTE (acc)</td><td>Meta Score</td></tr><tr><td></td><td>TF (baseline)</td><td>90.7</td><td>85.9/80.2</td><td>69.2/88.2</td><td>80.4/79.7</td><td>86.7</td><td>63.6</td><td>80.5</td></tr><tr><td>5</td><td>PF (baseline)</td><td>92.5</td><td>86.8/81.8</td><td>70.1/88.5</td><td>81.8/81.1</td><td>87.9</td><td>64.2</td><td>81.6</td></tr><tr><td></td><td>PD (our work)</td><td>91.8</td><td>86.8/81.7</td><td>70.4/88.9</td><td>82.8/82.2</td><td>88.9</td><td>65.3</td><td>82.1</td></tr><tr><td></td><td>Sun et al. (2019a)</td><td>92.0</td><td>85.0/79.9</td><td>70.7/88.9</td><td>81.5/81.0</td><td>89.0</td><td>65.5</td><td>81.7</td></tr><tr><td>哥</td><td>PF (baseline)</td><td>91.1</td><td>87.9/82.5</td><td>86.6/90.0</td><td>81.1/81.7</td><td>87.8</td><td>63.0</td><td>82.8</td></tr><tr><td></td><td>PD (our work)</td><td>91.1</td><td>89.4/84.9</td><td>87.4/90.7</td><td>82.5/83.4</td><td>89.4</td><td>66.7</td><td>84.4</td></tr><tr><td></td><td>Sanh (2019)</td><td>92.7</td><td>88.3/82.4</td><td>87.7/90.6</td><td>81.6/81.1</td><td>85.5</td><td>60.0</td><td>82.3</td></tr></table>
+
+Table 3: Model Quality. All students are 6/768 BERT models, trained by 12/768 BERT teachers. Concurrent results are cited as reported by their authors. Our dev results are averaged over 5 runs. Our test results are evaluated on the GLUE server, using the model that performed best on dev. For anchoring, we also provide our results for MLM pre-training followed by fine-tuning (PF) and cite results from Sun et al. (2019a) for BERTBASE truncated and fine-tuned (TF). The meta score is computed on 6 tasks only, and is therefore not directly comparable to the GLUE leaderboard.
+
+Figure 3: Pre-trained Distillation (PD) and concurrent work on model compression.
+
+While we are treating our large teachers as black boxes, it is worth noting that they are produced by pre-training and fine-tuning. Since the teacher could potentially transfer the knowledge it has obtained via pre-training to the student through distillation, it is a priori unclear whether pre-training the student would bring additional benefits. As Section 6.2 shows, pre-training students is surprisingly important, even when millions of samples are available for transfer.
+
+# 4 COMPARISON TO CONCURRENT WORK
+
+There are concurrent efforts to ours aiming to leverage both pre-training and distillation in the context of building compact models. Though inspired by the two-stage pre-training+fine-tuning approach that enabled deep-and-wide architectures to advance the state-of-the-art in language understanding, they depart from this traditional method in several key ways.
+
+Patient Knowledge Distillation (Sun et al., 2019a) initializes a student from the bottom layers of a deeper pre-trained model, then performs task-specific patient distillation. The training objective relies not only on the teacher output, but also on its intermediate layers, thus making assumptions about the student and teacher architectures. In a parallel line of work, DistilBert (Sanh, 2019) applies the same truncation-based initialization method for the student, then continues its LM pre-training via distillation from a more expensive LM teacher, and finally fine-tunes on task data. Its downside is that LM distillation is computationally expensive, as it requires a softmax operation over the entire vocabulary to compute the expensive LM teacher’s predictive distribution. A common limitation in both studies is that the initialization strategy constrains the student to the teacher embedding size. Table 2 summarizes the differences between concurrent work and Pre-trained Distillation (PD).
+
+To facilitate direct comparison, in this section we perform an experiment with the same model architecture, sizes and dataset settings used in the two studies mentioned above. We perform Pretrained Distillation on a 6-layer BERT student with task supervision from a 12-layer BERTBASE teacher, using embedding size 768 for both models. For distillation, our transfer set coincides with the labeled set $( \mathcal { D } _ { T } = \mathcal { D } _ { L } )$ ). Table 3 reports results on the 6 GLUE tasks selected by Sun et al. (2019a) and shows that, on average, PD performs best. For anchoring, we also provide quality numbers for pre-training+fine-tuning (PF), which is surprisingly competitive to the more elaborate alternatives in this setting where $\mathcal { D } _ { T }$ is not larger than $\mathcal { D } _ { L }$ . Remarkably, PF does not compromise generality or simplicity for quality. Its downside is, however, that it cannot leverage unlabeled task data and teacher model predictions.
+
+![](images/77fbb5692d144463a21bd245389fe11021ffb1252283f2bee4597aa3aa568785.jpg)  
+Figure 4: Baselines for building compact models, used for analysis (Section 6).
+
+# 5 ANALYSIS SETTINGS
+
+Given these positive results, we aim to gain more insight into Pre-trained Distillation. We perform extensive analyses on two orthogonal axes—model sizes and properties of unlabeled data, thus departing from the settings used in Section 4.
+
+All our models follow the Transformer architecture (Vaswani et al., 2017) and input processing used in BERT (Devlin et al., 2018). We denote the number of hidden layers as $L$ and the hidden embedding size as $H$ , and refer to models by their $L / H$ dimensions. We always fix the number of self-attention heads to $H / 6 4$ and the feed-forward/filter size to $4 H$ . The end-task models are obtained by stacking a linear classifier on top of the Transformer architectures.
+
+The teacher, BERTLARGE, has dimensions 24L/1024H and 340M parameters. We experiment with 24 student models, with sizes and relative latencies listed in Table 1. The most expensive student, TransformerBASE, is 3 times smaller and 1.25 times faster than the teacher; the cheapest student, TransformerSMALL, is 77 times smaller and 65 times faster. For readability, we report results on a selection of 5 students, but verify that all conclusions hold across the entire 24-model grid.
+
+# 5.1 ANALYSIS BASELINES
+
+We select three baselines for Pre-trained Distillation that can provide insights into the contributions made by each of its constituent operations.
+
+Basic Training (Figure 4a) is the standard supervised learning method: a compact model is trained directly on the labeled set.
+
+Knowledge Distillation (Figure 4b) (Bucila et al., 2006; Hinton et al., 2015) (or simply “distil- ˘ lation”) transfers information from a highly-parameterized and accurate teacher model to a more compact and thus less expressive student. For classification tasks, distillation exposes the student to soft labels, namely the class probabilities produced by the teacher $p _ { l } = \mathrm { s o f t m a x } ( z _ { l } / T )$ , where $p _ { l }$ is the output probability for class $l$ , $z _ { l }$ is the logit for class $l$ , and $T$ is a constant called temperature that controls the smoothness of the output distribution. The softness of the labels enables better generalization than the gold hard labels. For each end task, we train: $( i )$ a teacher obtained by fine-tuning pre-trained BERTLARGE (24L/1024H) on the labeled dataset (note teachers do not learn from the transfer set), and $( i i )$ 24 students of various sizes. Students are always distilled on the soft labels produced by the teacher with a temperature of $1 ^ { 2 }$ .
+
+Pre-training+Fine-tuning (Figure 4c) (Dai & Le, 2015; Devlin et al., 2018), or simply PF, leverages large unlabeled general-domain corpora to pre-train models that can be fine-tuned for end tasks.
+
+Following BERT, we perform pre-training with the masked LM (MLM) and next sentence objectives (collectively referred to as ${ \bf M } { \bf L } { \bf M } ^ { + }$ from here on). The resulting model is fine-tuned on end-task labeled data. While pre-training large models has been shown to provide substantial benefits, we are unaware of any prior work systematically studying its effectiveness on compact architectures.
+
+# 5.2 ANALYSIS TASKS AND DATASETS
+
+The tasks and associated datasets are summarized in Table 4.
+
+Sentiment classification aims to classify text according to the polarities of opinions it contains. We perform 3-way document classification on Amazon Book Reviews (He & McAuley, 2016). Its considerable size $( 8 \mathrm { m } )$ allows us to closely follow the standard distillation setting, where there is a large number of unlabeled examples for transfer. Additionally, we test our algorithm on SST-2 (Socher et al., 2013),
+
+Table 4: Datasets used for analysis. A star indicates that hard labels are discarded. $\mathrm { N L I ^ { * } }$ refers to the collection of MNLI (390k), SNLI (570k) and QQP (400k). The reviews datasets are part of Amazon Product Data. Unless otherwise stated, $\mathcal { D } _ { L M }$ consists of BookCorpus & English Wikipedia.   
+
+<table><tr><td>Labeled Data (DL)</td><td>Unlabeled Transfer Data (DT)</td></tr><tr><td>MNLI (390k)</td><td>NLI* (1.3m samples)</td></tr><tr><td>RTE (2.5k)</td><td>NLI* (1.3m samples)</td></tr><tr><td>SST-2 (68k)</td><td>Movie Reviews*(1.7m samples)</td></tr><tr><td>Book Reviews (50k)</td><td>Book Reviews* (8m samples)</td></tr></table>
+
+which is a binary sentence classification task, and our results are directly comparable with prior work on the GLUE leaderboard (Wang et al., 2018). We use whole documents from Amazon Movie Reviews $\mathrm { ( 1 . 7 m ) }$ as unlabeled transfer data (note that SST-2 consists of single sentences).
+
+Natural language inference involves classifying pairs of sentences (a premise and a hypothesis) as entailment, contradiction, or neutral. This task is representative of the scenario in which proxy data is non-trivial to gather (Gururangan et al., 2018). We chose MNLI (Williams et al., 2018) as our target dataset. Since strictly in-domain data is difficult to obtain, we supplement $\mathcal { D } _ { T }$ with two other sentence-pair datasets: SNLI (Bowman et al., 2015) and QQP (Chen et al., 2018).
+
+Textual entailment is similar to NLI, but restricted to binary classification (entailment vs nonentailment). The most popular RTE dataset (Bentivogli et al., 2009) is two orders of magnitude smaller than MNLI and offers an extreme test of robustness to the amount of transfer data.
+
+# 6 ANALYSIS
+
+In this section, we conduct experiments that help us understand why Pre-trained Distillation is successful and how to attribute credit to its constituent operations.
+
+6.1 THERE ARE NO SHORTCUTS: WHY FULL PRE-TRAINING IS NECESSARY
+
+As later elaborated in Section 7, earlier efforts to leverage pre-training in the context of compact models simply feed pre-trained (possibly contextual) input representations into randomly-initialized students (Hu et al., 2018; Chia et al., 2018; Tang et al., 2019). Concurrent work initializes shallowand-wide students from the bottom layers of their deeper pre-trained counterparts (Yang et al., 2019a; Sun et al., 2019a). The experiments below indicate these strategies are suboptimal, and that LM pre-training is necessary in order to unlock the full student potential.
+
+Is it enough to pre-train word embeddings? No. In order to prove that pre-training Transformer layers is important, we compare two flavors of Pre-trained Distillation3: PD with pre-trained word embeddings and PD with pre-trained word embeddings and Transformer layers. We produce wordpiece embeddings by pre-training one-layer Transformers for each embedding size. We then discard the single Transformer layer and keep the embeddings to initialize our students.
+
+For MNLI (Figure 5), less than $24 \%$ of the gains PD brings over distillation can be attributed to the pre-trained word embeddings (for TransformerTINY, this drops even lower, to $5 \%$ ). The rest of the benefits come from additionally pre-training the Transformer layers.
+
+![](images/43e17de266812a0ab9d4561873f0ff01e4265030084a98e2eb62d74b9877c084.jpg)  
+Figure 5: Pre-training outperforms truncation. Students initialized via LM pre-training (green) outperform those initialized from the bottom layers of 12-layer pre-trained models (gray). When only word embeddings are pre-trained (red), performance is degraded even further.
+
+![](images/aebd0b46f936db0cbc9d44f279df5b74b96cc9763678e0ae469dae89ad3cf5b9.jpg)  
+Figure 6: Depth outweighs width when models are pre-trained (PD and PF), as emphasized by the sharp drops in the plot. For instance, the 6L/512H $3 5 . 4 \mathrm { m }$ parameters) model outperforms the 2L/768H model $( 3 9 . 2 \mathrm { m }$ parameters). Randomly initialized models take poor advantage of extra parameters.
+
+Is it worse to truncate deep pre-trained models? Yes, especially for shallow students. Given that pre-training is an expensive process, an exhaustive search over model sizes in the pursuit of the one that meets a certain performance threshold can be impractical. Instead of pre-training all (number of layers, embedding size) combinations of students, one way of short-cutting the process is to pre-train a single deep (e.g. 12-layer) student for each embedding size, then truncate it at various heights. Figure 5 shows that this can be detrimental especially to shallow architectures; TransformerTINY loses more than $73 \%$ of the pre-training gains over distillation. As expected, losses fade away as the number of layers increases.
+
+What is the best student for a fixed parameter size budget? As a rule of thumb, prioritize depth over width, especially with pre-trained students. Figure 6 presents a comparison between 24 student model architectures on SST-2, demonstrating how well different students utilize model capacity. They are sorted first by the hidden size, then by the number of layers. This roughly corresponds to a monotonic increase in the number of parameters, with a few exceptions for the largest students. The quality of randomly initialized students (i.e. basic training and distillation) is closely correlated with the number of parameters. With pre-training (i.e. PD and PF), we observe two intuitive findings: (1) pre-trained models are much more effective at using more parameters, and (2) pre-trained models are particularly efficient at utilizing depth, as indicated by the sharp drops in performance when moving to wider but shallower models.
+
+This is yet another argument against initialization via truncation: for instance, truncating the bottom two layers of BERTBASE would lead to a suboptimal distribution of parameters: the 2L/768H model $( 3 9 . 2 \mathrm { m }$ parameters) is dramatically worse than e.g. 6L/512H $3 5 . 4 \mathrm { { m } }$ parameters).
+
+# 6.2 UNDER THE HOOD: DISSECTING PRE-TRAINED DISTILLATION
+
+In the previous section, we presented empirical evidence for the importance of the initial LM pretraining step. In this section, we show that distillation brings additional value, especially in the presence of a considerably-sized transfer set, and that fine-tuning ensures robustness when the unlabeled data diverges from the labeled set.
+
+Comparison to analysis baselines First, we quantify how much Pre-trained Distillation improves upon its constituent operations applied in isolation. We compare it against the baselines established in Section 5.1 (basic training, distillation, and pre-training+fine-tuning) on the three NLP tasks described in Section 5.2. We use the BookCorpus (Zhu et al., 2015) and English Wikipedia as our unlabeled LM set, following the same pre-training procedure as Devlin et al. (2018).
+
+![](images/b4cd71159546594ddcc9019fc475c636d9aebbac01a5cd60b56d5f90bce4e9a3.jpg)  
+Figure 7: Comparison against analysis baselines. Pre-trained Distillation out-performs all baselines: pretraining $^ +$ fine-tuning, distillation, and basic training over five different student sizes. Pre-training is performed on a large unlabeled LM set (BookCorpus & English Wikipedia). Distillation uses the task-specific unlabeled transfer sets listed in Table 4. Teachers are pre-trained BERTLARGE, fine-tuned on labeled data.
+
+Results in Figure 7 confirm that PD outperforms these baselines, with particularly remarkable results on the Amazon Book Reviews corpus, where TransformerMINI recovers the accuracy of the teacher at a 31x decrease in model size and 16x speed-up. Distillation achieves the same performance with TransformerBASE, which is $1 0 \mathrm { x }$ larger than TransformerMINI. Thus PD can compress the model more effectively than distillation. On RTE, Pre-trained Distillation improves TransformerTINY by more than $5 \%$ absolute over the closest baseline (pre-training+fine-tuning) and is the only method to recover teacher accuracy with TransformerBASE.
+
+It is interesting to note that the performance of the baseline systems is closely related to the size of the transfer set. For the sentence-pair tasks such as MNLI and RTE, where the size of the transfer set is moderate $( 1 . 3 \mathrm { m } )$ and slightly out-of-domain (see Table 4), pre-training $^ +$ fine-tuning out-performs distillation across all student sizes, with an average of $12 \%$ for MNLI and $8 \%$ on RTE. Interestingly, the order is inverted on Amazon Book Reviews, where the large transfer set $( 8 \mathrm { m } )$ is strictly indomain: distillation is better than pre-training+fine-tuning by an average of $3 \%$ . On the other hand, Pre-trained Distillation is consistently best in all cases. We will examine the robustness of Pre-trained Distillation in the rest of the section.
+
+Robustness to transfer set size It is generally accepted that distillation is reliant upon a large transfer set. For instance, distillation for speech recognition is performed on hundreds of millions of data points (Li et al., 2014; Hinton et al., 2015).
+
+We reaffirm this statement through experiments on Amazon Book Reviews in Figure 8, given that Amazon Book Reviews have the biggest transfer set. Distillation barely recovers teacher accuracy with the largest student (TransformerBASE), using the entire $8 \mathrm { m }$ transfer set. When there is only 1m transfer set, the performance is $4 \%$ behind the teacher model. In contrast, PD achieves the same performance with TransformerMINI on $5 \mathrm { m }$ instances. In other words, PD can match the teacher model with $1 0 \mathrm { x }$ smaller model and $1 . 5 \mathrm { x }$ less transfer data, compared to distillation.
+
+Robustness to domain shift To the best of our knowledge, there is no prior work that explicitly studies how distillation is impacted by the mismatch between training and transfer sets (which we will refer to as domain shift). Many previous distillation efforts focus on tasks where the two sets come from the same distribution (Romero et al., 2014; Hinton et al., 2015), while others simply acknowledge the importance of and strive for a close match between them (Bucila et al., 2006).˘
+
+We provide empirical evidence that out-of-domain data degrades distillation and that our algorithm is more robust to mismatches between $\mathcal { D } _ { L }$ and $\mathcal { D } _ { T }$ . We measure domain shift using the Spearman rank correlation coefficient (which we refer to as Spearman or simply $S$ ), introduced as a general metric in (Spearman, 1904) and first used as a corpus similarity metric in (Johansson et al., 1989). To compute corpus similarity, we follow the procedure described in (Kilgarriff & Rose, 1998): for two datasets $X$ and $Y$ , we compute the corresponding frequency ranks $F _ { X }$ and $F _ { Y }$ of their most computed. The final statistic is given by the following formula: common $n = 1 0 0$ words. For each of these words, the difference $\textstyle 1 - \sum _ { i = 1 } ^ { 1 0 0 } d _ { i } ^ { 2 } / ( n ( n ^ { 2 } - \bar { 1 } ) )$ $d$ between ranks in $F _ { X }$ and . $F _ { Y }$ is
+
+![](images/1d8a64717d9c95d9f72e3c2e03c8b63e4989df5847dee3af4b4c691774d9df16.jpg)  
+Figure 8: Robustness to transfer set size. We verify that distillation requires a large transfer set: $8 \mathrm { m }$ instances are needed to match the performance of the teacher using TransformerBASE. PD achieves the same performance with TransformerMINI, on a $5 \mathrm { m }$ transfer set $_ { 1 0 \mathrm { x } }$ smaller, 13x faster, $1 . 5 \mathrm { x }$ less data).
+
+![](images/37be866a802cddfef9df3b58215b74fb633501a09a85a6616aa0911e2fd2405c.jpg)  
+Figure 9: Robustness to domain shift in transfer set. By keeping $| \mathcal { D } _ { T } |$ fixed $( 1 . 7 \mathrm { m } )$ and varying the correlation between $\mathcal { D } _ { L }$ and $\mathcal { D } _ { T }$ (denoted by $S$ ), we show that distillation requires an in-domain transfer set. PD and PD-F are more robust to transfer set domain.
+
+To measure the effect of domain shift, we again experiment on the Amazon Book Reviews task. Instead of varying the size of the transfer sets, this time we keep size fixed (to $1 . 7 \mathrm { m }$ documents) and vary the source of the unlabeled text used for distillation. Transfer set domains vary from not task-related (paragraphs from Wikipedia with $S { = } 0 . 4 3$ ), to reviews for products of unrelated category (electronics reviews with $S { = } 0 . 5 2 \rangle$ ), followed by reviews from a related category (movie reviews with $S { = } 0 . 7 6 $ ), and finally in-domain book reviews $( S { = } 1 . 0 )$ . Results in Figure 9 show a direct correlation between accuracy and the Spearman coefficient for both distillation and PD. When $S$ drops to 0.43, distillation on $\mathcal { D } _ { T }$ is $1 . 8 \%$ worse than basic training on $\mathcal { D } _ { L }$ , whereas PD suffers a smaller loss over pre-training+fine-tuning, and a gain of about $1 . 5 \%$ when a final fine-tuning step is added. When reviews from an unrelated product are used as a transfer set ${ \it S } { = } 0 . 5 2 )$ , PD obtains a much larger gain from learning from the teacher, compared to distillation.
+
+We investigate the interaction between pretraining and distillation by applying them sequentially on the same data. We compare the following two algorithms: Pre-training+Finetuning with $\mathcal { D } _ { L M } = X$ and Pre-trained Distillation with $\mathcal { D } _ { L M } = \mathcal { D } _ { T } = X$ . Any additional gains that the latter brings over the former must be attributed to distillation, providing evidence that the compound effect still exists.
+
+For MNLI, we set $\mathcal { D } _ { L M } = \mathcal { D } _ { T } = \mathrm { N L I ^ { * } }$ and continue the experiment above by taking the students pre-trained on $\mathcal { D } _ { L M } = \mathrm { N L I ^ { * } }$ and distilling them on $\mathcal { D } _ { T } = \mathrm { N L I ^ { * } }$ . As shown in Figure 10, PD is better than PF by $2 . 2 \%$ on average over all student sizes. Note that even when pretraining and then distilling on the same data, PD outperforms the two training strategies applied in isolation. The two methods are thus learning different linguistic aspects, both useful for the end task.
+
+![](images/63beeefbe28c65b7f7cbe09b949b3ec3170b4b3548ce89ebf3f367632c6e235d.jpg)  
+6.3 BETTER TOGETHER: THE COMPOUND EFFECT OF PRE-TRAINING AND DISTILLATION   
+Figure 10: Pre-training complements distillation. PD outperforms the baselines even when we pre-train and distill on the same dataset $\mathcal { D } _ { L M } = \mathcal { D } _ { T } = \mathrm { N L I ^ { * } }$ ).
+
+# 7 RELATED WORK
+
+Pre-training Decades of research have shown that unlabeled text can help learn language representations. Word embeddings were first used (Mikolov et al., 2013; Pennington et al., 2014), while subsequently contextual word representations were found more effective (Peters et al., 2018). Most recently, research has shifted towards fine-tuning methods (Radford et al., 2018; Devlin et al., 2018; Radford et al., 2019), where entire large pre-trained representations are fine-tuned for end tasks together with a small number of task-specific parameters. While feature-based unsupervised representations have been successfully used in compact models (Johnson & Zhang, 2015; Gururangan et al., 2019), inter alia, the pretraining+fine-tuning approach has not been studied in depth for such small models.
+
+Learning compact models In this work we built on model compression (Bucila et al., 2006) and ˘ its variant knowledge distillation (Hinton et al., 2015). Other related efforts introduced ways to transfer more information from a teacher to a student model, by sharing intermediate layer activations (Romero et al., 2014; Yim et al., 2017; Sun et al., 2019a). We experimented with related approaches, but found only slight gains which were dominated by the gains from pre-training and were not complementary. Prior works have also noted the unavailability of in-domain large-scale transfer data and proposed the use of automatically generated pseudo-examples (Bucila et al., 2006; ˘ Kimura et al., 2018). Here we showed that large-scale general domain text can be successfully used for pre-training instead. A separate line of work uses pruning or quantization to derive smaller models (Han et al., 2016; Gupta et al., 2015). Gains from such techniques are expected to be complementary to PD.
+
+Distillation with unsupervised pre-training Early efforts to leverage both unsupervised pretraining and distillation provide pre-trained (possibly contextual) word embeddings as inputs to students, rather than pre-training the student stack. For instance, Hu et al. (2018) use ELMo embeddings, while (Chia et al., 2018; Tang et al., 2019) use context-independent word embeddings. Concurrent work initializes Transformer students from the bottom layers of a 12-layer BERT model (Yang et al., 2019a; Sun et al., 2019a; Sanh, 2019). The latter continues student LM pre-training via distillation from a more expensive LM teacher. For a different purpose of deriving a single model for multiple tasks through distillation, Clark et al. (2019) use a pre-trained student model of the same size as multiple teacher models. However, none of the prior work has analyzed the impact of unsupervised learning for students in relation to the model size and domain of the transfer set.
+
+# 8 CONCLUSION
+
+We conducted extensive experiments to gain understanding of how knowledge distillation and the pre-training+fine-tuning algorithm work in isolation, and how they interact. We made the finding that their benefits compound, and unveiled the power of Pre-trained Distillation, a simple yet effective method to maximize the utilization of all available resources: a powerful teacher, and multiple sources of data (labeled sets, unlabeled transfer sets, and unlabeled LM sets).
+
+# REFERENCES
+
+Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. The fifth pascal recognizing textual entailment challenge. In Proc Text Analysis Conference (TAC09, 2009.
+
+Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2015.
+
+C Bucila, R Caruana, and A Niculescu-Mizil. Model compression. In ˘ Proceedings of the 12th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 535– 541, 2006.
+
+Z. Chen, H. Zhang, X. Zhang, and L. Zhao. Quora question pairs. 2018.
+
+Yew Ken Chia, Sam Witteveen, and Martin Andrews. Transformer to cnn: Label-scarce distillation for efficient text classification. 2018.
+
+Kevin Clark, Minh-Thang Luong, Urvashi Khandelwal, Christopher D. Manning, and Quoc V. Le. BAM! born-again multi-task networks for natural language understanding. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, July 2019. Association for Computational Linguistics.
+
+Andrew M Dai and Quoc V Le. Semi-supervised sequence learning. In Advances in neural information processing systems, pp. 3079–3087, 2015.
+
+Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018.
+
+Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In ICML, 2015.
+
+Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel Bowman, and Noah A. Smith. Annotation artifacts in natural language inference data. In NAACL, 2018.
+
+Suchin Gururangan, Tam Dang, Dallas Card, and Noah A. Smith. Variational pretraining for semisupervised text classification. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, July 2019.
+
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In NIPS, 2016.
+
+Ruining He and Julian McAuley. Ups and downs: Modeling the visual evolution of fashion trends with one-class collaborative filtering. In proceedings of the 25th international conference on world wide web, pp. 507–517. International World Wide Web Conferences Steering Committee, 2016.
+
+Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015.
+
+Minghao Hu, Yuxing Peng, Furu Wei, Zhen Huang, Dongsheng Li, Nan Yang, and Ming Zhou. Attention-guided answer distillation for machine reading comprehension. arXiv preprint arXiv:1808.07644, 2018.
+
+Johansson, Stig, and Knut Hofland. Frequency Analysis of English vocabulary and grammar, based on the LOB corpus. Claredon, Oxford, 1989.
+
+Rie Johnson and Tong Zhang. Semi-supervised convolutional neural networks for text categorization via region embedding. In Advances in neural information processing systems, pp. 919–927, 2015.
+
+Adam Kilgarriff and Tony Rose. Measures for corpus similarity and homogeneity. In Proceedings of the Third Conference on Empirical Methods for Natural Language Processing, pp. 46–52, 1998.
+
+Young-Bum Kim, Karl Stratos, and Dongchan Kim. Adversarial adaptation of synthetic or stale data. In ACL, 2017.
+
+Akisato Kimura, Zoubin Ghahramani, Koh Takeuchi, Tomoharu Iwata, and Naonori Ueda. Fewshot learning of neural networks from scratch by pseudo example optimization. arXiv preprint arXiv:1802.03039, 2018.
+
+Jinyu Li, Rui Zhao, Jui-Ting Huang, and Yifan Gong. Learning small-size dnn with outputdistribution-based criteria. In Fifteenth annual conference of the international speech communication association, 2014.
+
+Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach, 2019.
+
+Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014.
+
+Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. arXiv preprint arXiv:1802.05365, 2018.
+
+Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openaiassets/research-covers/languageunsupervised/language understanding paper. pdf, 2018.
+
+Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. URL https://openai. com/blog/better-languagemodels, 2019.
+
+Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. arXiv preprint arXiv:1412.6550, 2014.
+
+Victor Sanh. Smaller, faster, cheaper, lighter: Introducing DistilBERT, a distilled version of BERT. https://medium.com/huggingface/distilbert-8cf3380435b5, 2019.
+
+Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013.
+
+Spearman. The proof and measurement of association between two things. In American Journal of Psychology., pp. 72–101, 1904.
+
+Siqi Sun, Yu Cheng, Zhe Gan, and Jingjing Liu. Patient knowledge distillation for bert model compression. arXiv preprint arXiv:1908.09355, 2019a.
+
+Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Hao Tian, Hua Wu, and Haifeng Wang. Ernie 2.0: A continual pre-training framework for language understanding, 2019b.
+
+Raphael Tang, Yao Lu, Linqing Liu, Lili Mou, Olga Vechtomova, and Jimmy Lin. Distilling taskspecific knowledge from bert into simple neural networks, 2019.
+
+Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017.
+
+Alex Wang, Amapreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461, 2018.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1112–1122. Association for Computational Linguistics, 2018. URL http://aclweb.org/anthology/N18-1101.
+
+Ze Yang, Linjun Shou, Ming Gong, Wutao Lin, and Daxin Jiang. Model compression with multi-task knowledge distillation for web-scale question answering system. arXiv preprint arXiv:1904.09636, 2019a.
+
+Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint arXiv:1906.08237, 2019b.
+
+Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017.
+
+Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pp. 19–27, 2015.

parse/train/BJg7x1HFvB/BJg7x1HFvB_content_list.json

@@ -0,0 +1,1570 @@
+[
+    {
+        "type": "text",
+        "text": "WELL-READ STUDENTS LEARN BETTER: ON THE IMPORTANCE OF PRE-TRAINING COMPACT MODELS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent developments in natural language representations have been accompanied by large and expensive models that leverage vast amounts of general-domain text through self-supervised pre-training. Due to the cost of applying such models to down-stream tasks, several model compression techniques on pre-trained language representations have been proposed (Sun et al., 2019a; Sanh, 2019). However, surprisingly, the simple baseline of just pre-training and fine-tuning compact models has been overlooked. In this paper, we first show that pre-training remains important in the context of smaller architectures, and fine-tuning pre-trained compact models can be competitive to more elaborate methods proposed in concurrent work. Starting with pre-trained compact models, we then explore transferring task knowledge from large fine-tuned models through standard knowledge distillation. The resulting simple, yet effective and general algorithm, Pre-trained Distillation, brings further improvements. Through extensive experiments, we more generally explore the interaction between pre-training and distillation under two variables that have been under-studied: model size and properties of unlabeled task data. One surprising observation is that they have a compound effect even when sequentially applied on the same data. To accelerate future research, we will make our 24 pre-trained miniature BERT models publicly available. ",
+        "bbox": [
+            233,
+            266,
+            764,
+            517
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            544,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Self-supervised learning on a general-domain text corpus followed by end-task learning is the twostaged training approach that enabled deep-and-wide Transformer-based networks (Vaswani et al., 2017) to advance language understanding (Devlin et al., 2018; Yang et al., 2019b; Sun et al., 2019b; Liu et al., 2019). However, state-of-the-art models have hundreds of millions of parameters, incurring a high computational cost. Our goal is to realize their gains under a restricted memory and latency budget. We seek a training method that is well-performing, general and simple and can leverage additional resources such as unlabeled task data. ",
+        "bbox": [
+            174,
+            575,
+            823,
+            672
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Before considering compression techniques, we start with the following research question: Could we directly train small models using the same two-staged approach? In other words, we explore the idea of applying language model (LM) pre-training and task fine-tuning to compact architectures directly. This simple baseline has so far been overlooked by the NLP community, potentially based on an underlying assumption that the limited capacity of compact models is capitalized better when focusing on the end task rather than a general language model objective. Concurrent work to ours proposes variations of the standard pre-training+fine-tuning procedure, but with limited generality (Sun et al., 2019a; Sanh, 2019). We make the surprising finding that pre-training+fine-tuning in its original formulation is a competitive method for building compact models. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            805
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "For further gains, we additionally leverage knowledge distillation (Hinton et al., 2015), the standard technique for model compression. A compact student is trained to recover the predictions of a highly accurate teacher. In addition to the posited regularization effect of these soft labels (Hinton et al., 2015), distillation provides a means of producing pseudo-labels for unlabeled data. By regarding LM pre-training of compact models as a student initialization strategy, we can take advantage of both methods. The resulting algorithm is a sequence of three standard training operations: masked LM (MLM) pre-training (Devlin et al., 2018), task-specific distillation, and optional fine-tuning. From here on, we will refer to it as Pre-trained Distillation (PD) (Figure 1). As we will show in ",
+        "bbox": [
+            174,
+            811,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/f20fb237743e755cb02fd23f0f3575d24a1fa24ce671852eb43c326c4d807d41.jpg",
+        "image_caption": [
+            "Figure 1: Pre-trained Distillation "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            104,
+            534,
+            267
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbbc5cbdd7d1bfb03160815edb3fa08d2dcb5e389bcc8253d8e21feeb0f1551d.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            555,
+            94,
+            787,
+            265
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Section 6.2, PD outperforms the pre-training $^ +$ fine-tuning (PF) baseline, especially in the presence of a large transfer set for distillation. ",
+        "bbox": [
+            174,
+            309,
+            823,
+            337
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In a controlled study following data and model architecture settings in concurrent work (Section 4), we show that Pre-trained Distillation outperforms or is competitive with more elaborate approaches which use either more sophisticated distillation of task knowledge (Sun et al., 2019a) or more sophisticated pre-training from unlabeled text (Sanh, 2019). The former distill task knowledge from intermediate teacher activations, starting with a heuristically initialized student. The latter fine-tune a compact model that is pre-trained on unlabeled text with the help of a larger LM teacher. ",
+        "bbox": [
+            174,
+            344,
+            825,
+            428
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "One of the most noteworthy contributions of our paper are the extensive experiments that examine how Pre-trained Distillation and its baselines perform under various conditions. We investigate two axes that have been under-studied in previous work: model size and amount/quality of unlabeled data. While experimenting with 24 models of various sizes ( $4 \\mathrm m$ to $1 1 0 \\mathrm { m }$ parameters) and depth/width trade-offs, we observe that pre-trained students can leverage depth much better than width; in contrast, this property is not visible for randomly-initialized models. For the second axis, we vary the amount of unlabeled data, as well as its similarity to the labeled set. Interestingly, Pretrained Distillation is more robust to these variations in the transfer set than standard distillation. ",
+        "bbox": [
+            174,
+            435,
+            825,
+            546
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally, in order to gain insight into the interaction between LM pre-training and task-specific distillation, we sequentially apply these operations on the same dataset. In this experiment, chaining the two operations performs better than any one of them applied in isolation, despite the fact that a single dataset was used for both steps. This compounding effect is surprising, indicating that pre-training and distillation are learning complementary aspects of the data. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            623
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Given the effectiveness of LM pre-training on compact architectures, we will make our 24 pretrained miniature BERT models publicly available in order to accelerate future research. ",
+        "bbox": [
+            174,
+            630,
+            821,
+            659
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            393,
+            696
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our high-level goal is to build accurate models which fit a given memory and latency budget. There are many aspects to explore: the parametric form of the compact model (architecture, number of parameters, trade-off between number of hidden layers and embedding size), the training data (size, distribution, presence or absence of labels, training objective), etc. Since an exhaustive search over this space is impractical, we fix the model architecture to bidirectional Transformers, known to be suitable for a wide range of NLP tasks (Vaswani et al., 2017; Devlin et al., 2018). The rest of this section elaborates on the training resources we assume to have at our disposal. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The teacher is a highly accurate but large model for an end task, that does not meet the resource constraints. Prior work on distillation often makes use of an ensemble of networks (Hinton et al., 2015). For faster experimentation, we use a single teacher, without making a statement about the best architectural choice. In Section 4, the teacher is pre-trained BERTBASE fine-tuned on labeled end-task data. In Section 6, we use BERTLARGE instead. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Students are compact models that satisfy resource constraints. Since model size qualifiers are relative (e.g., what is considered small in a data center can be impractically large on a mobile device), ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "(a) Millions of parameters ",
+        "bbox": [
+            259,
+            185,
+            415,
+            199
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/fc0077efb690435b6ebba674dc674a5aa7ed2ab93db083e0d472826a67afcf25.jpg",
+        "table_caption": [
+            "Table 1: Student models with various numbers of transformer layers $\\mathbf { \\Pi } ( \\mathbf { L } )$ and hidden embedding sizes $\\mathbf { \\Pi } ( \\mathbf { H } )$ . Latency is computed on Cloud TPUs with batch size 1 and sequence length 512. For readability, we focus on five models (underlined) for most figures: Tiny ( $_ { \\mathrm { L } = 2 }$ , $\\mathrm { H } { = } 1 2 \\bar { 8 }$ ), Mini $\\mathrm { L } { = } 4$ , $_ { \\mathrm { H } = 2 5 6 }$ ), Small $\\mathrm { L } { = } 4$ , $_ { \\mathrm { H } = 5 1 2 }$ ), Medium $\\mathrm { L } { = } 8$ , $_ { \\mathrm { H } = 5 1 2 }$ ), and Base ( $_ { \\mathrm { L } = 1 2 }$ , $_ { \\mathrm { H } = 7 6 8 }$ ). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>H=128</td><td>H=256</td><td>H=512</td><td>H=768</td></tr><tr><td>L=2</td><td>4.4</td><td>9.7</td><td>22.8</td><td>39.2</td></tr><tr><td>L=4</td><td>4.8</td><td>11.3</td><td>29.1</td><td>53.4</td></tr><tr><td>L=6</td><td>5.2</td><td>12.8</td><td>35.4</td><td>67.5</td></tr><tr><td>L=8</td><td>5.6</td><td>14.4</td><td>41.7</td><td>81.7</td></tr><tr><td>L=10</td><td>6.0</td><td>16.0</td><td>48.0</td><td>95.9</td></tr><tr><td>L=12</td><td>6.4</td><td>17.6</td><td>54.3</td><td>110.1</td></tr></table>",
+        "bbox": [
+            186,
+            75,
+            488,
+            179
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/28c06c993855fb80c84ef64bd5e10ed5bfcbc45775231d7ed4161036e10ede13.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Relative speedup wrt BERTLARGE on TPU v2 "
+        ],
+        "table_body": "<table><tr><td></td><td>H=128</td><td>H=256</td><td>H=512</td><td>H=768</td></tr><tr><td>L=2</td><td>65.24</td><td>31.25</td><td>14.44</td><td>7.46</td></tr><tr><td>L=4</td><td>32.37</td><td>15.96</td><td>7.27</td><td>3.75</td></tr><tr><td>L=6</td><td>21.87</td><td>10.67</td><td>4.85</td><td>2.50</td></tr><tr><td>L=8</td><td>16.42</td><td>8.01</td><td>3.64</td><td>1.88</td></tr><tr><td>L=10</td><td>13.05</td><td>6.37</td><td>2.90</td><td>1.50</td></tr><tr><td>L=12</td><td>11.02</td><td>5.35</td><td>2.43</td><td>1.25</td></tr></table>",
+        "bbox": [
+            511,
+            77,
+            813,
+            180
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "we investigate an array of 24 model sizes, from our TransformerTINY ( $4 \\mathrm m$ parameters) all the way up to TransformerBASE ( $1 1 0 \\mathrm { m }$ parameters)1. The student model sizes and their relative speed-up compared to the BERTLARGE teacher can be found in Table 1. Interested readers can situate themselves on this spectrum based on their resource constraints. For readability, most plots show a selection of 5 models, but we verify that our conclusions hold for all 24. ",
+        "bbox": [
+            174,
+            276,
+            825,
+            345
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Labeled data $( \\mathcal { D } _ { L } )$ is a set of $N$ training examples $\\left\\{ ( x _ { 1 } , y _ { 1 } ) , . . . , ( x _ { N } , y _ { N } ) \\right\\}$ , where $x _ { i }$ is an input and $y _ { i }$ is a label. For most NLP tasks, labeled sets are hard to produce and thus restricted in size. ",
+        "bbox": [
+            171,
+            352,
+            823,
+            381
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlabeled transfer data $( \\mathcal { D } _ { T } )$ is a set of $M$ input examples of the form $\\{ x _ { 1 } ^ { \\prime } , . . . , x _ { M } ^ { \\prime } \\}$ sampled from a distribution that is similar to but possibly not identical to the input distribution of the labeled set. During distillation, the teacher transfers knowledge to the student by exposing its label predictions for instances $ { \\boldsymbol { { x } } } _ { m } ^ { \\prime }$ . $\\mathcal { D } _ { T }$ can also include the input portion of labeled data $\\mathcal { D } _ { L }$ instances. Due to the lack of true labels, such sets are generally easier to produce and consequently larger than labeled ones. Note, however, that task-relevant input text is not readily available for key tasks requiring paired texts such as natural language inference and question answering, as well as domain-specific dialog understanding. In addition, for deployed systems, input data distribution shifts over time and existing unlabeled data becomes stale (Kim et al., 2017). ",
+        "bbox": [
+            173,
+            387,
+            825,
+            513
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Unlabeled language model data $( \\mathcal { D } _ { L M } )$ is a collection of natural language texts that enable unsupervised learning of text representations. We use it for unsupervised pre-training with a masked language model objective (Devlin et al., 2018). Because no labels are needed and strong domain similarity is not required, these corpora are often vast, containing thousands of millions of words. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            577
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The distinction between the three types of datasets is strictly functional. Note they are not necessarily disjunct. For instance, the same corpus that forms the labeled data can also be part of the unlabeled transfer set, after its labels are discarded. Similarly, corpora that are included in the transfer set can also be used as unlabeled LM data. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PRE-TRAINED DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            659,
+            447,
+            675
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Pre-trained Distillation (PD) (Figure 1) is a general, yet simple algorithm for building compact models that can leverage all the resources enumerated in Section 2. It consists of a sequence of three standard training operations that can be applied to any choice of architecture: ",
+        "bbox": [
+            176,
+            690,
+            823,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "1. Pre-training on $\\mathcal { D } _ { L M }$ . A compact model is trained with a masked LM objective (Devlin et al., 2018), capturing linguistic phenomena from a large corpus of natural language texts.   \n2. Distillation on $\\mathcal { D } _ { T }$ . This well-read student is now prepared to take full advantage of the teacher expertise, and is trained on the soft labels (predictive distribution) produced by the teacher. As we will show in Section 6.2, randomly initialized distillation is constrained by the size and distribution of its unlabeled transfer set. However, the previous pre-training step mitigates to some extent the negative effects caused by an imperfect transfer set.   \n3. (Optional) fine-tuning on $\\mathcal { D } _ { L }$ . This step makes the model robust to potential mismatches between the distribution of the transfer and labeled sets. We will refer to the two-step algorithm as PD, and to the three-step algorithm as PDF. ",
+        "bbox": [
+            207,
+            739,
+            825,
+            888
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/3c03605ccfaa71facc7c5d2f5dcc7ca330e96c2e4378ae9139fca90f5170bc32.jpg",
+        "table_caption": [
+            "Table 2: Training Strategies that build compact models by applying language model (LM) pretraining before knowledge distillation (KD). The first two rows apply distillation on task data. The third row applies distillation with an LM objective on general-domain data. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Step 1 (DLm)</td><td>Step 2(Dr = DL)</td><td>Architecture-agnostic</td></tr><tr><td>PD (our work)</td><td>LM pre-training</td><td>KD</td><td>√</td></tr><tr><td>Sun et al. (2019a)</td><td>BERTBASE truncated</td><td>Patient-KD</td><td>X</td></tr><tr><td>Sanh (2019)</td><td>BERTBASE truncated + LM-KD</td><td>Fine-tuning</td><td>×</td></tr></table>",
+        "bbox": [
+            176,
+            88,
+            820,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/84da34fa5d306ae0a92dba4a80a1a57af3e05beaaf5590377426285f13eed127.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td></td><td>SST-2 (acc)</td><td>MRPC (f1/acc)</td><td>QQP (f1/acc)</td><td>MNLI (acc m/mm)</td><td>QNLI (acc)</td><td>RTE (acc)</td><td>Meta Score</td></tr><tr><td></td><td>TF (baseline)</td><td>90.7</td><td>85.9/80.2</td><td>69.2/88.2</td><td>80.4/79.7</td><td>86.7</td><td>63.6</td><td>80.5</td></tr><tr><td>5</td><td>PF (baseline)</td><td>92.5</td><td>86.8/81.8</td><td>70.1/88.5</td><td>81.8/81.1</td><td>87.9</td><td>64.2</td><td>81.6</td></tr><tr><td></td><td>PD (our work)</td><td>91.8</td><td>86.8/81.7</td><td>70.4/88.9</td><td>82.8/82.2</td><td>88.9</td><td>65.3</td><td>82.1</td></tr><tr><td></td><td>Sun et al. (2019a)</td><td>92.0</td><td>85.0/79.9</td><td>70.7/88.9</td><td>81.5/81.0</td><td>89.0</td><td>65.5</td><td>81.7</td></tr><tr><td>哥</td><td>PF (baseline)</td><td>91.1</td><td>87.9/82.5</td><td>86.6/90.0</td><td>81.1/81.7</td><td>87.8</td><td>63.0</td><td>82.8</td></tr><tr><td></td><td>PD (our work)</td><td>91.1</td><td>89.4/84.9</td><td>87.4/90.7</td><td>82.5/83.4</td><td>89.4</td><td>66.7</td><td>84.4</td></tr><tr><td></td><td>Sanh (2019)</td><td>92.7</td><td>88.3/82.4</td><td>87.7/90.6</td><td>81.6/81.1</td><td>85.5</td><td>60.0</td><td>82.3</td></tr></table>",
+        "bbox": [
+            176,
+            236,
+            821,
+            382
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Table 3: Model Quality. All students are 6/768 BERT models, trained by 12/768 BERT teachers. Concurrent results are cited as reported by their authors. Our dev results are averaged over 5 runs. Our test results are evaluated on the GLUE server, using the model that performed best on dev. For anchoring, we also provide our results for MLM pre-training followed by fine-tuning (PF) and cite results from Sun et al. (2019a) for BERTBASE truncated and fine-tuned (TF). The meta score is computed on 6 tasks only, and is therefore not directly comparable to the GLUE leaderboard. ",
+        "bbox": [
+            173,
+            391,
+            825,
+            476
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Figure 3: Pre-trained Distillation (PD) and concurrent work on model compression. ",
+        "bbox": [
+            225,
+            487,
+            771,
+            502
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While we are treating our large teachers as black boxes, it is worth noting that they are produced by pre-training and fine-tuning. Since the teacher could potentially transfer the knowledge it has obtained via pre-training to the student through distillation, it is a priori unclear whether pre-training the student would bring additional benefits. As Section 6.2 shows, pre-training students is surprisingly important, even when millions of samples are available for transfer. ",
+        "bbox": [
+            174,
+            532,
+            825,
+            602
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 COMPARISON TO CONCURRENT WORK",
+        "text_level": 1,
+        "bbox": [
+            176,
+            626,
+            529,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "There are concurrent efforts to ours aiming to leverage both pre-training and distillation in the context of building compact models. Though inspired by the two-stage pre-training+fine-tuning approach that enabled deep-and-wide architectures to advance the state-of-the-art in language understanding, they depart from this traditional method in several key ways. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            714
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Patient Knowledge Distillation (Sun et al., 2019a) initializes a student from the bottom layers of a deeper pre-trained model, then performs task-specific patient distillation. The training objective relies not only on the teacher output, but also on its intermediate layers, thus making assumptions about the student and teacher architectures. In a parallel line of work, DistilBert (Sanh, 2019) applies the same truncation-based initialization method for the student, then continues its LM pre-training via distillation from a more expensive LM teacher, and finally fine-tunes on task data. Its downside is that LM distillation is computationally expensive, as it requires a softmax operation over the entire vocabulary to compute the expensive LM teacher’s predictive distribution. A common limitation in both studies is that the initialization strategy constrains the student to the teacher embedding size. Table 2 summarizes the differences between concurrent work and Pre-trained Distillation (PD). ",
+        "bbox": [
+            174,
+            722,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To facilitate direct comparison, in this section we perform an experiment with the same model architecture, sizes and dataset settings used in the two studies mentioned above. We perform Pretrained Distillation on a 6-layer BERT student with task supervision from a 12-layer BERTBASE teacher, using embedding size 768 for both models. For distillation, our transfer set coincides with the labeled set $( \\mathcal { D } _ { T } = \\mathcal { D } _ { L } )$ ). Table 3 reports results on the 6 GLUE tasks selected by Sun et al. (2019a) and shows that, on average, PD performs best. For anchoring, we also provide quality numbers for pre-training+fine-tuning (PF), which is surprisingly competitive to the more elaborate alternatives in this setting where $\\mathcal { D } _ { T }$ is not larger than $\\mathcal { D } _ { L }$ . Remarkably, PF does not compromise generality or simplicity for quality. Its downside is, however, that it cannot leverage unlabeled task data and teacher model predictions. ",
+        "bbox": [
+            176,
+            868,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/77fbb5692d144463a21bd245389fe11021ffb1252283f2bee4597aa3aa568785.jpg",
+        "image_caption": [
+            "Figure 4: Baselines for building compact models, used for analysis (Section 6). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            87,
+            833,
+            196
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            236,
+            825,
+            319
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 ANALYSIS SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            340,
+            380,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Given these positive results, we aim to gain more insight into Pre-trained Distillation. We perform extensive analyses on two orthogonal axes—model sizes and properties of unlabeled data, thus departing from the settings used in Section 4. ",
+        "bbox": [
+            174,
+            372,
+            823,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "All our models follow the Transformer architecture (Vaswani et al., 2017) and input processing used in BERT (Devlin et al., 2018). We denote the number of hidden layers as $L$ and the hidden embedding size as $H$ , and refer to models by their $L / H$ dimensions. We always fix the number of self-attention heads to $H / 6 4$ and the feed-forward/filter size to $4 H$ . The end-task models are obtained by stacking a linear classifier on top of the Transformer architectures. ",
+        "bbox": [
+            174,
+            421,
+            823,
+            491
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The teacher, BERTLARGE, has dimensions 24L/1024H and 340M parameters. We experiment with 24 student models, with sizes and relative latencies listed in Table 1. The most expensive student, TransformerBASE, is 3 times smaller and 1.25 times faster than the teacher; the cheapest student, TransformerSMALL, is 77 times smaller and 65 times faster. For readability, we report results on a selection of 5 students, but verify that all conclusions hold across the entire 24-model grid. ",
+        "bbox": [
+            174,
+            497,
+            825,
+            566
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 ANALYSIS BASELINES",
+        "text_level": 1,
+        "bbox": [
+            176,
+            584,
+            369,
+            598
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We select three baselines for Pre-trained Distillation that can provide insights into the contributions made by each of its constituent operations. ",
+        "bbox": [
+            176,
+            611,
+            821,
+            638
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Basic Training (Figure 4a) is the standard supervised learning method: a compact model is trained directly on the labeled set. ",
+        "bbox": [
+            176,
+            645,
+            820,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Knowledge Distillation (Figure 4b) (Bucila et al., 2006; Hinton et al., 2015) (or simply “distil- ˘ lation”) transfers information from a highly-parameterized and accurate teacher model to a more compact and thus less expressive student. For classification tasks, distillation exposes the student to soft labels, namely the class probabilities produced by the teacher $p _ { l } = \\mathrm { s o f t m a x } ( z _ { l } / T )$ , where $p _ { l }$ is the output probability for class $l$ , $z _ { l }$ is the logit for class $l$ , and $T$ is a constant called temperature that controls the smoothness of the output distribution. The softness of the labels enables better generalization than the gold hard labels. For each end task, we train: $( i )$ a teacher obtained by fine-tuning pre-trained BERTLARGE (24L/1024H) on the labeled dataset (note teachers do not learn from the transfer set), and $( i i )$ 24 students of various sizes. Students are always distilled on the soft labels produced by the teacher with a temperature of $1 ^ { 2 }$ . ",
+        "bbox": [
+            173,
+            681,
+            825,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Pre-training+Fine-tuning (Figure 4c) (Dai & Le, 2015; Devlin et al., 2018), or simply PF, leverages large unlabeled general-domain corpora to pre-train models that can be fine-tuned for end tasks. ",
+        "bbox": [
+            173,
+            827,
+            821,
+            854
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following BERT, we perform pre-training with the masked LM (MLM) and next sentence objectives (collectively referred to as ${ \\bf M } { \\bf L } { \\bf M } ^ { + }$ from here on). The resulting model is fine-tuned on end-task labeled data. While pre-training large models has been shown to provide substantial benefits, we are unaware of any prior work systematically studying its effectiveness on compact architectures. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 ANALYSIS TASKS AND DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            176,
+            446,
+            190
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The tasks and associated datasets are summarized in Table 4. ",
+        "bbox": [
+            174,
+            203,
+            449,
+            231
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Sentiment classification aims to classify text according to the polarities of opinions it contains. We perform 3-way document classification on Amazon Book Reviews (He & McAuley, 2016). Its considerable size $( 8 \\mathrm { m } )$ allows us to closely follow the standard distillation setting, where there is a large number of unlabeled examples for transfer. Additionally, we test our algorithm on SST-2 (Socher et al., 2013), ",
+        "bbox": [
+            174,
+            238,
+            450,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/461b33f55620146b58b1423effb161c63870e48fcce8ce7049dbc9288bcc1dc4.jpg",
+        "table_caption": [
+            "Table 4: Datasets used for analysis. A star indicates that hard labels are discarded. $\\mathrm { N L I ^ { * } }$ refers to the collection of MNLI (390k), SNLI (570k) and QQP (400k). The reviews datasets are part of Amazon Product Data. Unless otherwise stated, $\\mathcal { D } _ { L M }$ consists of BookCorpus & English Wikipedia. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Labeled Data (DL)</td><td>Unlabeled Transfer Data (DT)</td></tr><tr><td>MNLI (390k)</td><td>NLI* (1.3m samples)</td></tr><tr><td>RTE (2.5k)</td><td>NLI* (1.3m samples)</td></tr><tr><td>SST-2 (68k)</td><td>Movie Reviews*(1.7m samples)</td></tr><tr><td>Book Reviews (50k)</td><td>Book Reviews* (8m samples)</td></tr></table>",
+        "bbox": [
+            464,
+            207,
+            823,
+            286
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "which is a binary sentence classification task, and our results are directly comparable with prior work on the GLUE leaderboard (Wang et al., 2018). We use whole documents from Amazon Movie Reviews $\\mathrm { ( 1 . 7 m ) }$ as unlabeled transfer data (note that SST-2 consists of single sentences). ",
+        "bbox": [
+            174,
+            377,
+            820,
+            417
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Natural language inference involves classifying pairs of sentences (a premise and a hypothesis) as entailment, contradiction, or neutral. This task is representative of the scenario in which proxy data is non-trivial to gather (Gururangan et al., 2018). We chose MNLI (Williams et al., 2018) as our target dataset. Since strictly in-domain data is difficult to obtain, we supplement $\\mathcal { D } _ { T }$ with two other sentence-pair datasets: SNLI (Bowman et al., 2015) and QQP (Chen et al., 2018). ",
+        "bbox": [
+            174,
+            425,
+            825,
+            494
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Textual entailment is similar to NLI, but restricted to binary classification (entailment vs nonentailment). The most popular RTE dataset (Bentivogli et al., 2009) is two orders of magnitude smaller than MNLI and offers an extreme test of robustness to the amount of transfer data. ",
+        "bbox": [
+            174,
+            502,
+            820,
+            544
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            290,
+            580
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we conduct experiments that help us understand why Pre-trained Distillation is successful and how to attribute credit to its constituent operations. ",
+        "bbox": [
+            176,
+            595,
+            821,
+            625
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6.1 THERE ARE NO SHORTCUTS: WHY FULL PRE-TRAINING IS NECESSARY",
+        "bbox": [
+            174,
+            640,
+            714,
+            655
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "As later elaborated in Section 7, earlier efforts to leverage pre-training in the context of compact models simply feed pre-trained (possibly contextual) input representations into randomly-initialized students (Hu et al., 2018; Chia et al., 2018; Tang et al., 2019). Concurrent work initializes shallowand-wide students from the bottom layers of their deeper pre-trained counterparts (Yang et al., 2019a; Sun et al., 2019a). The experiments below indicate these strategies are suboptimal, and that LM pre-training is necessary in order to unlock the full student potential. ",
+        "bbox": [
+            174,
+            667,
+            825,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Is it enough to pre-train word embeddings? No. In order to prove that pre-training Transformer layers is important, we compare two flavors of Pre-trained Distillation3: PD with pre-trained word embeddings and PD with pre-trained word embeddings and Transformer layers. We produce wordpiece embeddings by pre-training one-layer Transformers for each embedding size. We then discard the single Transformer layer and keep the embeddings to initialize our students. ",
+        "bbox": [
+            174,
+            766,
+            825,
+            837
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For MNLI (Figure 5), less than $24 \\%$ of the gains PD brings over distillation can be attributed to the pre-trained word embeddings (for TransformerTINY, this drops even lower, to $5 \\%$ ). The rest of the benefits come from additionally pre-training the Transformer layers. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            886
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/43e17de266812a0ab9d4561873f0ff01e4265030084a98e2eb62d74b9877c084.jpg",
+        "image_caption": [
+            "Figure 5: Pre-training outperforms truncation. Students initialized via LM pre-training (green) outperform those initialized from the bottom layers of 12-layer pre-trained models (gray). When only word embeddings are pre-trained (red), performance is degraded even further. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            163,
+            90,
+            473,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/aebd0b46f936db0cbc9d44f279df5b74b96cc9763678e0ae469dae89ad3cf5b9.jpg",
+        "image_caption": [
+            "Figure 6: Depth outweighs width when models are pre-trained (PD and PF), as emphasized by the sharp drops in the plot. For instance, the 6L/512H $3 5 . 4 \\mathrm { m }$ parameters) model outperforms the 2L/768H model $( 3 9 . 2 \\mathrm { m }$ parameters). Randomly initialized models take poor advantage of extra parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            498,
+            90,
+            810,
+            319
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Is it worse to truncate deep pre-trained models? Yes, especially for shallow students. Given that pre-training is an expensive process, an exhaustive search over model sizes in the pursuit of the one that meets a certain performance threshold can be impractical. Instead of pre-training all (number of layers, embedding size) combinations of students, one way of short-cutting the process is to pre-train a single deep (e.g. 12-layer) student for each embedding size, then truncate it at various heights. Figure 5 shows that this can be detrimental especially to shallow architectures; TransformerTINY loses more than $73 \\%$ of the pre-training gains over distillation. As expected, losses fade away as the number of layers increases. ",
+        "bbox": [
+            174,
+            439,
+            825,
+            550
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "What is the best student for a fixed parameter size budget? As a rule of thumb, prioritize depth over width, especially with pre-trained students. Figure 6 presents a comparison between 24 student model architectures on SST-2, demonstrating how well different students utilize model capacity. They are sorted first by the hidden size, then by the number of layers. This roughly corresponds to a monotonic increase in the number of parameters, with a few exceptions for the largest students. The quality of randomly initialized students (i.e. basic training and distillation) is closely correlated with the number of parameters. With pre-training (i.e. PD and PF), we observe two intuitive findings: (1) pre-trained models are much more effective at using more parameters, and (2) pre-trained models are particularly efficient at utilizing depth, as indicated by the sharp drops in performance when moving to wider but shallower models. ",
+        "bbox": [
+            174,
+            569,
+            825,
+            708
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "This is yet another argument against initialization via truncation: for instance, truncating the bottom two layers of BERTBASE would lead to a suboptimal distribution of parameters: the 2L/768H model $( 3 9 . 2 \\mathrm { m }$ parameters) is dramatically worse than e.g. 6L/512H $3 5 . 4 \\mathrm { { m } }$ parameters). ",
+        "bbox": [
+            176,
+            715,
+            823,
+            757
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6.2 UNDER THE HOOD: DISSECTING PRE-TRAINED DISTILLATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            647,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the previous section, we presented empirical evidence for the importance of the initial LM pretraining step. In this section, we show that distillation brings additional value, especially in the presence of a considerably-sized transfer set, and that fine-tuning ensures robustness when the unlabeled data diverges from the labeled set. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            862
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Comparison to analysis baselines First, we quantify how much Pre-trained Distillation improves upon its constituent operations applied in isolation. We compare it against the baselines established in Section 5.1 (basic training, distillation, and pre-training+fine-tuning) on the three NLP tasks described in Section 5.2. We use the BookCorpus (Zhu et al., 2015) and English Wikipedia as our unlabeled LM set, following the same pre-training procedure as Devlin et al. (2018). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/b4cd71159546594ddcc9019fc475c636d9aebbac01a5cd60b56d5f90bce4e9a3.jpg",
+        "image_caption": [
+            "Figure 7: Comparison against analysis baselines. Pre-trained Distillation out-performs all baselines: pretraining $^ +$ fine-tuning, distillation, and basic training over five different student sizes. Pre-training is performed on a large unlabeled LM set (BookCorpus & English Wikipedia). Distillation uses the task-specific unlabeled transfer sets listed in Table 4. Teachers are pre-trained BERTLARGE, fine-tuned on labeled data. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            161,
+            87,
+            823,
+            246
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            339,
+            821,
+            367
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Results in Figure 7 confirm that PD outperforms these baselines, with particularly remarkable results on the Amazon Book Reviews corpus, where TransformerMINI recovers the accuracy of the teacher at a 31x decrease in model size and 16x speed-up. Distillation achieves the same performance with TransformerBASE, which is $1 0 \\mathrm { x }$ larger than TransformerMINI. Thus PD can compress the model more effectively than distillation. On RTE, Pre-trained Distillation improves TransformerTINY by more than $5 \\%$ absolute over the closest baseline (pre-training+fine-tuning) and is the only method to recover teacher accuracy with TransformerBASE. ",
+        "bbox": [
+            173,
+            375,
+            825,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "It is interesting to note that the performance of the baseline systems is closely related to the size of the transfer set. For the sentence-pair tasks such as MNLI and RTE, where the size of the transfer set is moderate $( 1 . 3 \\mathrm { m } )$ and slightly out-of-domain (see Table 4), pre-training $^ +$ fine-tuning out-performs distillation across all student sizes, with an average of $12 \\%$ for MNLI and $8 \\%$ on RTE. Interestingly, the order is inverted on Amazon Book Reviews, where the large transfer set $( 8 \\mathrm { m } )$ is strictly indomain: distillation is better than pre-training+fine-tuning by an average of $3 \\%$ . On the other hand, Pre-trained Distillation is consistently best in all cases. We will examine the robustness of Pre-trained Distillation in the rest of the section. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            590
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Robustness to transfer set size It is generally accepted that distillation is reliant upon a large transfer set. For instance, distillation for speech recognition is performed on hundreds of millions of data points (Li et al., 2014; Hinton et al., 2015). ",
+        "bbox": [
+            174,
+            611,
+            823,
+            652
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We reaffirm this statement through experiments on Amazon Book Reviews in Figure 8, given that Amazon Book Reviews have the biggest transfer set. Distillation barely recovers teacher accuracy with the largest student (TransformerBASE), using the entire $8 \\mathrm { m }$ transfer set. When there is only 1m transfer set, the performance is $4 \\%$ behind the teacher model. In contrast, PD achieves the same performance with TransformerMINI on $5 \\mathrm { m }$ instances. In other words, PD can match the teacher model with $1 0 \\mathrm { x }$ smaller model and $1 . 5 \\mathrm { x }$ less transfer data, compared to distillation. ",
+        "bbox": [
+            174,
+            660,
+            823,
+            742
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Robustness to domain shift To the best of our knowledge, there is no prior work that explicitly studies how distillation is impacted by the mismatch between training and transfer sets (which we will refer to as domain shift). Many previous distillation efforts focus on tasks where the two sets come from the same distribution (Romero et al., 2014; Hinton et al., 2015), while others simply acknowledge the importance of and strive for a close match between them (Bucila et al., 2006).˘ ",
+        "bbox": [
+            174,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We provide empirical evidence that out-of-domain data degrades distillation and that our algorithm is more robust to mismatches between $\\mathcal { D } _ { L }$ and $\\mathcal { D } _ { T }$ . We measure domain shift using the Spearman rank correlation coefficient (which we refer to as Spearman or simply $S$ ), introduced as a general metric in (Spearman, 1904) and first used as a corpus similarity metric in (Johansson et al., 1989). To compute corpus similarity, we follow the procedure described in (Kilgarriff & Rose, 1998): for two datasets $X$ and $Y$ , we compute the corresponding frequency ranks $F _ { X }$ and $F _ { Y }$ of their most computed. The final statistic is given by the following formula: common $n = 1 0 0$ words. For each of these words, the difference $\\textstyle 1 - \\sum _ { i = 1 } ^ { 1 0 0 } d _ { i } ^ { 2 } / ( n ( n ^ { 2 } - \\bar { 1 } ) )$ $d$ between ranks in $F _ { X }$ and . $F _ { Y }$ is ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/1d8a64717d9c95d9f72e3c2e03c8b63e4989df5847dee3af4b4c691774d9df16.jpg",
+        "image_caption": [
+            "Figure 8: Robustness to transfer set size. We verify that distillation requires a large transfer set: $8 \\mathrm { m }$ instances are needed to match the performance of the teacher using TransformerBASE. PD achieves the same performance with TransformerMINI, on a $5 \\mathrm { m }$ transfer set $_ { 1 0 \\mathrm { x } }$ smaller, 13x faster, $1 . 5 \\mathrm { x }$ less data). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            90,
+            480,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/37be866a802cddfef9df3b58215b74fb633501a09a85a6616aa0911e2fd2405c.jpg",
+        "image_caption": [
+            "Figure 9: Robustness to domain shift in transfer set. By keeping $| \\mathcal { D } _ { T } |$ fixed $( 1 . 7 \\mathrm { m } )$ and varying the correlation between $\\mathcal { D } _ { L }$ and $\\mathcal { D } _ { T }$ (denoted by $S$ ), we show that distillation requires an in-domain transfer set. PD and PD-F are more robust to transfer set domain. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            511,
+            93,
+            805,
+            310
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            417,
+            823,
+            448
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "To measure the effect of domain shift, we again experiment on the Amazon Book Reviews task. Instead of varying the size of the transfer sets, this time we keep size fixed (to $1 . 7 \\mathrm { m }$ documents) and vary the source of the unlabeled text used for distillation. Transfer set domains vary from not task-related (paragraphs from Wikipedia with $S { = } 0 . 4 3$ ), to reviews for products of unrelated category (electronics reviews with $S { = } 0 . 5 2 \\rangle$ ), followed by reviews from a related category (movie reviews with $S { = } 0 . 7 6 $ ), and finally in-domain book reviews $( S { = } 1 . 0 )$ . Results in Figure 9 show a direct correlation between accuracy and the Spearman coefficient for both distillation and PD. When $S$ drops to 0.43, distillation on $\\mathcal { D } _ { T }$ is $1 . 8 \\%$ worse than basic training on $\\mathcal { D } _ { L }$ , whereas PD suffers a smaller loss over pre-training+fine-tuning, and a gain of about $1 . 5 \\%$ when a final fine-tuning step is added. When reviews from an unrelated product are used as a transfer set ${ \\it S } { = } 0 . 5 2 )$ , PD obtains a much larger gain from learning from the teacher, compared to distillation. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            606
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We investigate the interaction between pretraining and distillation by applying them sequentially on the same data. We compare the following two algorithms: Pre-training+Finetuning with $\\mathcal { D } _ { L M } = X$ and Pre-trained Distillation with $\\mathcal { D } _ { L M } = \\mathcal { D } _ { T } = X$ . Any additional gains that the latter brings over the former must be attributed to distillation, providing evidence that the compound effect still exists. ",
+        "bbox": [
+            174,
+            654,
+            483,
+            777
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "For MNLI, we set $\\mathcal { D } _ { L M } = \\mathcal { D } _ { T } = \\mathrm { N L I ^ { * } }$ and continue the experiment above by taking the students pre-trained on $\\mathcal { D } _ { L M } = \\mathrm { N L I ^ { * } }$ and distilling them on $\\mathcal { D } _ { T } = \\mathrm { N L I ^ { * } }$ . As shown in Figure 10, PD is better than PF by $2 . 2 \\%$ on average over all student sizes. Note that even when pretraining and then distilling on the same data, PD outperforms the two training strategies applied in isolation. The two methods are thus learning different linguistic aspects, both useful for the end task. ",
+        "bbox": [
+            174,
+            785,
+            483,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/63beeefbe28c65b7f7cbe09b949b3ec3170b4b3548ce89ebf3f367632c6e235d.jpg",
+        "image_caption": [
+            "6.3 BETTER TOGETHER: THE COMPOUND EFFECT OF PRE-TRAINING AND DISTILLATION ",
+            "Figure 10: Pre-training complements distillation. PD outperforms the baselines even when we pre-train and distill on the same dataset $\\mathcal { D } _ { L M } = \\mathcal { D } _ { T } = \\mathrm { N L I ^ { * } }$ ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            527,
+            652,
+            790,
+            844
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            910,
+            594,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            344,
+            117
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pre-training Decades of research have shown that unlabeled text can help learn language representations. Word embeddings were first used (Mikolov et al., 2013; Pennington et al., 2014), while subsequently contextual word representations were found more effective (Peters et al., 2018). Most recently, research has shifted towards fine-tuning methods (Radford et al., 2018; Devlin et al., 2018; Radford et al., 2019), where entire large pre-trained representations are fine-tuned for end tasks together with a small number of task-specific parameters. While feature-based unsupervised representations have been successfully used in compact models (Johnson & Zhang, 2015; Gururangan et al., 2019), inter alia, the pretraining+fine-tuning approach has not been studied in depth for such small models. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            257
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Learning compact models In this work we built on model compression (Bucila et al., 2006) and ˘ its variant knowledge distillation (Hinton et al., 2015). Other related efforts introduced ways to transfer more information from a teacher to a student model, by sharing intermediate layer activations (Romero et al., 2014; Yim et al., 2017; Sun et al., 2019a). We experimented with related approaches, but found only slight gains which were dominated by the gains from pre-training and were not complementary. Prior works have also noted the unavailability of in-domain large-scale transfer data and proposed the use of automatically generated pseudo-examples (Bucila et al., 2006; ˘ Kimura et al., 2018). Here we showed that large-scale general domain text can be successfully used for pre-training instead. A separate line of work uses pruning or quantization to derive smaller models (Han et al., 2016; Gupta et al., 2015). Gains from such techniques are expected to be complementary to PD. ",
+        "bbox": [
+            174,
+            272,
+            825,
+            426
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Distillation with unsupervised pre-training Early efforts to leverage both unsupervised pretraining and distillation provide pre-trained (possibly contextual) word embeddings as inputs to students, rather than pre-training the student stack. For instance, Hu et al. (2018) use ELMo embeddings, while (Chia et al., 2018; Tang et al., 2019) use context-independent word embeddings. Concurrent work initializes Transformer students from the bottom layers of a 12-layer BERT model (Yang et al., 2019a; Sun et al., 2019a; Sanh, 2019). The latter continues student LM pre-training via distillation from a more expensive LM teacher. For a different purpose of deriving a single model for multiple tasks through distillation, Clark et al. (2019) use a pre-trained student model of the same size as multiple teacher models. However, none of the prior work has analyzed the impact of unsupervised learning for students in relation to the model size and domain of the transfer set. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            579
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            599,
+            318,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We conducted extensive experiments to gain understanding of how knowledge distillation and the pre-training+fine-tuning algorithm work in isolation, and how they interact. We made the finding that their benefits compound, and unveiled the power of Pre-trained Distillation, a simple yet effective method to maximize the utilization of all available resources: a powerful teacher, and multiple sources of data (labeled sets, unlabeled transfer sets, and unlabeled LM sets). ",
+        "bbox": [
+            174,
+            631,
+            825,
+            700
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            722,
+            285,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Luisa Bentivogli, Ido Dagan, Hoa Trang Dang, Danilo Giampiccolo, and Bernardo Magnini. The fifth pascal recognizing textual entailment challenge. In Proc Text Analysis Conference (TAC09, 2009. ",
+        "bbox": [
+            174,
+            744,
+            825,
+            785
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel R. Bowman, Gabor Angeli, Christopher Potts, and Christopher D. Manning. A large annotated corpus for learning natural language inference. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing (EMNLP). Association for Computational Linguistics, 2015. ",
+        "bbox": [
+            173,
+            794,
+            825,
+            851
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C Bucila, R Caruana, and A Niculescu-Mizil. Model compression. In ˘ Proceedings of the 12th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, pp. 535– 541, 2006. ",
+        "bbox": [
+            176,
+            858,
+            825,
+            901
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Z. Chen, H. Zhang, X. Zhang, and L. Zhao. Quora question pairs. 2018. ",
+        "bbox": [
+            173,
+            909,
+            647,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yew Ken Chia, Sam Witteveen, and Martin Andrews. Transformer to cnn: Label-scarce distillation for efficient text classification. 2018. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kevin Clark, Minh-Thang Luong, Urvashi Khandelwal, Christopher D. Manning, and Quoc V. Le. BAM! born-again multi-task networks for natural language understanding. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, July 2019. Association for Computational Linguistics. ",
+        "bbox": [
+            174,
+            142,
+            825,
+            199
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew M Dai and Quoc V Le. Semi-supervised sequence learning. In Advances in neural information processing systems, pp. 3079–3087, 2015. ",
+        "bbox": [
+            173,
+            209,
+            823,
+            239
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. Bert: Pre-training of deep bidirectional transformers for language understanding. arXiv preprint arXiv:1810.04805, 2018. ",
+        "bbox": [
+            173,
+            248,
+            823,
+            277
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Suyog Gupta, Ankur Agrawal, Kailash Gopalakrishnan, and Pritish Narayanan. Deep learning with limited numerical precision. In ICML, 2015. ",
+        "bbox": [
+            173,
+            287,
+            825,
+            318
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Suchin Gururangan, Swabha Swayamdipta, Omer Levy, Roy Schwartz, Samuel Bowman, and Noah A. Smith. Annotation artifacts in natural language inference data. In NAACL, 2018. ",
+        "bbox": [
+            171,
+            327,
+            823,
+            357
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Suchin Gururangan, Tam Dang, Dallas Card, and Noah A. Smith. Variational pretraining for semisupervised text classification. In Proceedings of the 57th Annual Meeting of the Association for Computational Linguistics, Florence, Italy, July 2019. ",
+        "bbox": [
+            176,
+            366,
+            825,
+            410
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. In NIPS, 2016. ",
+        "bbox": [
+            174,
+            420,
+            825,
+            449
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ruining He and Julian McAuley. Ups and downs: Modeling the visual evolution of fashion trends with one-class collaborative filtering. In proceedings of the 25th international conference on world wide web, pp. 507–517. International World Wide Web Conferences Steering Committee, 2016. ",
+        "bbox": [
+            174,
+            458,
+            825,
+            515
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Oriol Vinyals, and Jeff Dean. Distilling the knowledge in a neural network. arXiv preprint arXiv:1503.02531, 2015. ",
+        "bbox": [
+            173,
+            525,
+            823,
+            555
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Minghao Hu, Yuxing Peng, Furu Wei, Zhen Huang, Dongsheng Li, Nan Yang, and Ming Zhou. Attention-guided answer distillation for machine reading comprehension. arXiv preprint arXiv:1808.07644, 2018. ",
+        "bbox": [
+            173,
+            564,
+            825,
+            608
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Johansson, Stig, and Knut Hofland. Frequency Analysis of English vocabulary and grammar, based on the LOB corpus. Claredon, Oxford, 1989. ",
+        "bbox": [
+            171,
+            618,
+            825,
+            647
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Rie Johnson and Tong Zhang. Semi-supervised convolutional neural networks for text categorization via region embedding. In Advances in neural information processing systems, pp. 919–927, 2015. ",
+        "bbox": [
+            173,
+            656,
+            823,
+            686
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Adam Kilgarriff and Tony Rose. Measures for corpus similarity and homogeneity. In Proceedings of the Third Conference on Empirical Methods for Natural Language Processing, pp. 46–52, 1998. ",
+        "bbox": [
+            173,
+            695,
+            825,
+            726
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Young-Bum Kim, Karl Stratos, and Dongchan Kim. Adversarial adaptation of synthetic or stale data. In ACL, 2017. ",
+        "bbox": [
+            173,
+            736,
+            823,
+            765
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Akisato Kimura, Zoubin Ghahramani, Koh Takeuchi, Tomoharu Iwata, and Naonori Ueda. Fewshot learning of neural networks from scratch by pseudo example optimization. arXiv preprint arXiv:1802.03039, 2018. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            818
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jinyu Li, Rui Zhao, Jui-Ting Huang, and Yifan Gong. Learning small-size dnn with outputdistribution-based criteria. In Fifteenth annual conference of the international speech communication association, 2014. ",
+        "bbox": [
+            171,
+            828,
+            823,
+            871
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, and Veselin Stoyanov. Roberta: A robustly optimized bert pretraining approach, 2019. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomas Mikolov, Ilya Sutskever, Kai Chen, Greg S Corrado, and Jeff Dean. Distributed representations of words and phrases and their compositionality. In Advances in neural information processing systems, pp. 3111–3119, 2013. ",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pp. 1532–1543, 2014. ",
+        "bbox": [
+            174,
+            155,
+            821,
+            198
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthew E Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. arXiv preprint arXiv:1802.05365, 2018. ",
+        "bbox": [
+            174,
+            205,
+            825,
+            248
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Karthik Narasimhan, Tim Salimans, and Ilya Sutskever. Improving language understanding by generative pre-training. URL https://s3-us-west-2. amazonaws. com/openaiassets/research-covers/languageunsupervised/language understanding paper. pdf, 2018. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            300
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alec Radford, Jeffrey Wu, Rewon Child, David Luan, Dario Amodei, and Ilya Sutskever. Language models are unsupervised multitask learners. URL https://openai. com/blog/better-languagemodels, 2019. ",
+        "bbox": [
+            174,
+            308,
+            823,
+            351
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adriana Romero, Nicolas Ballas, Samira Ebrahimi Kahou, Antoine Chassang, Carlo Gatta, and Yoshua Bengio. Fitnets: Hints for thin deep nets. arXiv preprint arXiv:1412.6550, 2014. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            388
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Victor Sanh. Smaller, faster, cheaper, lighter: Introducing DistilBERT, a distilled version of BERT. https://medium.com/huggingface/distilbert-8cf3380435b5, 2019. ",
+        "bbox": [
+            174,
+            396,
+            821,
+            426
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Richard Socher, Alex Perelygin, Jean Wu, Jason Chuang, Christopher D Manning, Andrew $\\mathrm { N g }$ , and Christopher Potts. Recursive deep models for semantic compositionality over a sentiment treebank. In Proceedings of the 2013 conference on empirical methods in natural language processing, pp. 1631–1642, 2013. ",
+        "bbox": [
+            173,
+            434,
+            825,
+            491
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Spearman. The proof and measurement of association between two things. In American Journal of Psychology., pp. 72–101, 1904. ",
+        "bbox": [
+            173,
+            500,
+            823,
+            529
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Siqi Sun, Yu Cheng, Zhe Gan, and Jingjing Liu. Patient knowledge distillation for bert model compression. arXiv preprint arXiv:1908.09355, 2019a. ",
+        "bbox": [
+            173,
+            536,
+            823,
+            565
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yu Sun, Shuohuan Wang, Yukun Li, Shikun Feng, Hao Tian, Hua Wu, and Haifeng Wang. Ernie 2.0: A continual pre-training framework for language understanding, 2019b. ",
+        "bbox": [
+            173,
+            573,
+            823,
+            603
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Raphael Tang, Yao Lu, Linqing Liu, Lili Mou, Olga Vechtomova, and Jimmy Lin. Distilling taskspecific knowledge from bert into simple neural networks, 2019. ",
+        "bbox": [
+            171,
+            611,
+            821,
+            640
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems, pp. 5998–6008, 2017. ",
+        "bbox": [
+            173,
+            648,
+            825,
+            691
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Wang, Amapreet Singh, Julian Michael, Felix Hill, Omer Levy, and Samuel R Bowman. Glue: A multi-task benchmark and analysis platform for natural language understanding. arXiv preprint arXiv:1804.07461, 2018. ",
+        "bbox": [
+            174,
+            699,
+            823,
+            742
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pp. 1112–1122. Association for Computational Linguistics, 2018. URL http://aclweb.org/anthology/N18-1101. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            821
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ze Yang, Linjun Shou, Ming Gong, Wutao Lin, and Daxin Jiang. Model compression with multi-task knowledge distillation for web-scale question answering system. arXiv preprint arXiv:1904.09636, 2019a. ",
+        "bbox": [
+            171,
+            830,
+            821,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zhilin Yang, Zihang Dai, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, and Quoc V Le. Xlnet: Generalized autoregressive pretraining for language understanding. arXiv preprint arXiv:1906.08237, 2019b. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Junho Yim, Donggyu Joo, Jihoon Bae, and Junmo Kim. A gift from knowledge distillation: Fast optimization, network minimization and transfer learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yukun Zhu, Ryan Kiros, Rich Zemel, Ruslan Salakhutdinov, Raquel Urtasun, Antonio Torralba, and Sanja Fidler. Aligning books and movies: Towards story-like visual explanations by watching movies and reading books. In Proceedings of the IEEE international conference on computer vision, pp. 19–27, 2015. ",
+        "bbox": [
+            176,
+            155,
+            825,
+            210
+        ],
+        "page_idx": 12
+    }
+]

parse/train/ByeZ5jC5YQ/ByeZ5jC5YQ.md

@@ -0,0 +1,576 @@
+# KNOCKOFFGAN: GENERATING KNOCKOFFS FOR FEATURE SELECTION USING GENERATIVE ADVERSARIAL NETWORKS
+
+James Jordon   
+Engineering Science Department   
+University of Oxford, UK   
+james.jordon@wolfson.ox.ac.uk   
+Jinsung Yoon   
+Department of Electrical and Computer Engineering   
+UCLA, California, USA   
+jsyoon0823@g.ucla.edu   
+Mihaela van der Schaar   
+University of Cambridge, UK   
+Department of Electrical and Computer Engineering, UCLA, California, USA   
+Alan Turing Institute, London, UK   
+mihaela@ee.ucla.edu
+
+# ABSTRACT
+
+Feature selection is a pervasive problem. The discovery of relevant features can be as important for performing a particular task (such as to avoid overfitting in prediction) as it can be for understanding the underlying processes governing the true label (such as discovering relevant genetic factors for a disease). Machine learning driven feature selection can enable discovery from large, high-dimensional, nonlinear observational datasets by creating a subset of features for experts to focus on. In order to use expert time most efficiently, we need a principled methodology capable of controlling the False Discovery Rate. In this work, we build on the promising Knockoff framework by developing a flexible knockoff generation model. We adapt the Generative Adversarial Networks framework to allow us to generate knockoffs with no assumptions on the feature distribution. Our model consists of 4 networks, a generator, a discriminator, a stability network and a power network. We demonstrate the capability of our model to perform feature selection, showing that it performs as well as the originally proposed knockoff generation model in the Gaussian setting and that it outperforms the original model in non-Gaussian settings, including on a real-world dataset.
+
+# 1 INTRODUCTION
+
+Feature selection is a pervasive problem. Often the goal is to discover features that are relevant to a particular outcome, either for the sake of discovery itself or to aid in prediction [16; 25]. When the focus is on discovery, feature selection methods typically focus on trying to control either the Family-Wise Error Rate (FWER) or the False Discovery Rate (FDR). The FWER measures the probability of making a single false discovery (a Type I error) among the selected features (i.e. selecting one which is not relevant), whereas the FDR measures the proportion of false discoveries made (i.e. the proportion of selected features which are false). Controlling FWER, however, leads to reduced power (i.e. selecting fewer relevant variables) since it controls the probability of making any false discovery, whereas FDR tries to control the proportion of false discoveries.
+
+Controlling the FDR is important [5; 6; 3]. Often, data-driven feature selection will be used to select a set of candidate features for further investigation. When further investigation is expensive (for example when further investigation would involve conducting new experiments and collecting more data), a method that cannot control the FDR may result in a large amount of wasted resources, with no guarantee that anything meaningful will be discovered. On the other hand, being able to control the FDR at, say, $10 \%$ ensures that at most, $10 \%$ of the spent resources are wasted, and $90 \%$ are in fact spent on discovering positive, useful results. It should be noted, however, that estimating the FDR of a method empirically is hard in practice, since we do not have access to the ground truth relevance. As such, a theoretical analysis of the method and its (potential) FDR-controlling properties must be carried out, which does not exist for many existing feature selection methods.
+
+[3] is the seminal paper on the knockoff framework, which is an innovative FDR-controlling feature selection method. Knockoffs are features that are generated to “look like” the real features but be conditionally independent of the label given the real features. Feature statistics (such as the coefficients of a LASSO [32]) are compared between the real features and their knockoffs and a selection is made when this difference is sufficiently large. Performing the selection in this way allows for an estimate of the FDR to be obtained and the selection threshold can be adjusted to control the FDR at the selected level. In the original paper, the relationship between the label and the features is constrained to be of a very specific form; in [7], they remove this constraint and instead provide a theoretical analysis that shifts the burden of knowledge onto knowing the underlying feature distribution. Unfortunately, while the theoretical results hold for any feature distribution, they rely on being able to generate valid knockoffs, for which [7] only provide a method for generating knockoffs when the distribution is a (known) multivariate Gaussian distribution. In this paper, we modify the Generative Adversarial Networks (GAN) [11] framework to address this problem, allowing us to generate knockoffs for any distribution (and without any prior knowledge of it). GANs have been shown to be a powerful method for learning to generate complex distributions [24; 20; 2].
+
+Our main contribution is in modifying the discriminator used in the GAN framework in such a way that the generator learns to generate knockoffs satisfying the necessary swap condition [7] which requires that when a feature and its knockoff are swapped, the joint distribution remains unchanged. In addition, we propose a method for maximizing the power of our model using Mutual Information Neural Estimation (MINE) [4] and investigate a regularization method to improve the stability of training. Our model consists of four networks: (1) a generator network that takes as input noise and the real features, and outputs a set of candidate knockoff features; (2) a discriminator network taking as input “swapped” feature-knockoff features that attempts to determine which variables have been swapped; (3) a Wasserstein GAN discriminator that we use as a regularization term; and (4) a MINE network that estimates the mutual information between each feature-knockoff pair allowing us to maximize the power of the knockoff procedure.
+
+# 2 RELATED WORKS
+
+Feature selection is a well-studied problem with a wealth of related works ([12; 31; 17; 22] provide a summary of a lot of existing literature); however, most methods do not attempt to control the FDR. The most common feature selection method for FDR control is the Benjamini-Hochberg (BHq) procedure and its variants [5; 6], which relies on obtaining valid marginal p-values for each selection.
+
+Knockoffs are an active area of research [9; 18; 10]. The notion of a knockoff was first introduced in [3] with the theory there requiring that the relationship between the features and the label be of a specific form. In [7], they build on the knockoff framework, removing this requirement but instead shifting the requirement to one of knowing the distribution of the features. As noted in the introduction, the theory in [7] holds independent of the distribution of the features - relying only on being able to generate valid knockoffs (which exist for any distribution of features). However, they only propose a method for generating knockoffs when the distribution of features is jointly Gaussian. While they do propose a method for generating approximate knockoffs in the non-Gaussian setting (by simply approximating the features as Gaussian), the guarantees on FDR control do not hold for their approximate knockoffs. In [26] and [10], they add to the class of constructible knockoffs, describing methods for constructing knockoffs for Markov Chains, Hidden Markov Models and Gaussian Mixture Models. Though once again, knowledge of the full distribution is still necessary for their construction.
+
+In this paper we use a framework motivated by GANs [11] to learn to generate knockoffs without any assumptions on the distribution of the features. To do this, we modify the discriminator so that rather than trying to determine whether a sample is real or fake, it attempts to identify which components have been “swapped”. In [38], an unconventional discriminator is used that performs component-wise discrimination for the purpose of imputation. While the problem addressed in that paper is different to the one here, the key idea relies on a similar modification to the discriminator to be able to appropriately guide the generator.
+
+In order to maximize the power of our variable selection mechanism, it will be desirable that the feature-knockoff pairs are ”as independent as possible” (this is discussed in [7]). In order to achieve this we will investigate the use of a promising recent paper, MINE [4]. MINE proposes a neural architecture and training procedure capable of estimating the mutual information between two random variables. As the mutual information between two random variables is zero only when they are independent, we will use this as a measure of independence and attempt to minimize it during the training of our modified GAN.
+
+# 3 BACKGROUND
+
+In this section we introduce our notation and define knockoffs as in [7]. Let us denote the feature space by $\mathcal { X }$ and the label space by $\mathcal { V }$ . Let the dimension of $\mathcal { X }$ be $d$ . Suppose that $\mathbf { X } = ( X _ { 1 } , . . . , X _ { d } )$ and $Y$ are random variables over $\mathcal { X }$ and $\mathcal { V }$ . As in [7], we will work with the notion of a null set.
+
+Definition 1. A variable $X _ { j }$ is said to be ”null” if and only if $Y$ is independent of $X _ { j }$ conditional on $\{ X _ { i } : i \neq j \}$ . We define $\mathcal { H } _ { \mathrm { 0 } }$ to be the set of all null variables.
+
+Our goal will be to discover as many relevant features as possible while controlling the FDR. For a given (potentially random) selection procedure that selects $\hat { S } \subset \{ 1 , . . . , d \}$ , we define the FDR to be
+
+$$
+\mathrm { F D R } = \mathbb { E } \left[ \frac { \left| \hat { S } \cap \mathcal { H } _ { 0 } \right| } { \left| \hat { S } \right| } \right] .
+$$
+
+Note that this agrees with the usual notion of FDR (i.e. when defined in terms of the Markov blanket) under mild assumptions (for a more thorough discussion see [7]).
+
+# 3.1 KNOCKOFFS
+
+Definition 2. A knockoff [7] for $\mathbf { X }$ is a random variable $\tilde { \textbf { X } } \in ~ \mathcal { X }$ satisfying the following two properties:
+
+$$
+\begin{array} { r } { ( \mathbf { X } , \tilde { \mathbf { X } } ) \stackrel { d . } { = } ( \mathbf { X } , \tilde { \mathbf { X } } ) _ { s w a p ( S ) } } \\ { \tilde { \mathbf { X } } \perp \perp Y | \mathbf { X } ~ } \end{array}
+$$
+
+for all $S \subset \{ 1 , . . . , d \}$ where $( \cdot , \cdot ) _ { s w a p ( S ) }$ denotes the vector obtained by swapping the ith component with the $( i + d ) t h$ component for each $i \in S a n d \overset { d . } { = } i .$ s equality in distribution.
+
+In order to use knockoffs for feature selection, we must define an appropriate feature statistic, $W _ { j }$ , that depends on ${ \bf x } , \tilde { \bf x }$ and $Y$ , i.e. $W _ { j } = w _ { j } ( ( { \bf X } , \tilde { { \bf X } } ) , Y )$ for some function $w _ { j }$ . This function $w _ { j }$ must satisfy the following flip-sign property:
+
+$$
+w _ { j } ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) _ { \operatorname { s w a p } ( S ) } , Y ) = { \left\{ \begin{array} { l l } { w _ { j } ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) , Y ) { \mathrm { ~ i f ~ } } j \notin S } \\ { - w _ { j } ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) , Y ) { \mathrm { ~ i f ~ } } j \in S . } \end{array} \right. }
+$$
+
+One of the procedures used in [7] to construct these statistics is to perform LASSO, treating the augmented feature-knockoffs as the features on which to regress. This gives LASSO coefficients $b _ { 1 } , . . . , b _ { 2 d }$ , and the statistic $W _ { j }$ is set to be the LASSO Coefficient Difference given by
+
+$$
+W _ { j } = | b _ { j } | - | b _ { j + d } | .
+$$
+
+Note that the FDR control guarantees hold independently of the choice of statistic, but a poorly chosen statistic can significantly impact the power of the test. In particular, using the LASSO Coefficient Difference in non-linear settings can yield few discoveries. The focus of this paper, however, is on generating the knockoffs, not on the statistic used on top of the generated knockoffs and so in our synthetic experiments, we use a linear model for $Y$ to be able to draw fair comparisons between our model and [7]. In the real world data experiment, we use a statistic based on Random Forests for both methods [37].
+
+The following result from [7] depends only on having obtained knockoffs that satisfy Definition 2 and feature statistics satisfying (3) (and in particular do not depend specifically on using LASSO to obtain the statistics).
+
+Theorem 1. Let $q \in [ 0 , 1 ]$ . Given test statistics, $W _ { 1 } , . . . , W _ { d } ,$ satisfying (3), let
+
+$$
+\tau = \operatorname* { m i n } \left\{ t > 0 : \frac { 1 + | \{ j : W _ { j } \leq - t \} | } { | \{ j : W _ { j } \geq t \} | } \leq q \right\} .
+$$
+
+Then the procedure selecting the variables
+
+controls the FDR at level q, i.e.
+
+$$
+\hat { S } = \{ j : W _ { j } \geq \tau \}
+$$
+
+$$
+\mathbb { E } \left[ \frac { \vert \hat { \boldsymbol { \mathcal { S } } } \boldsymbol { \cap } \mathcal { H } _ { 0 } \vert } { \vert \hat { \boldsymbol { \mathcal { S } } } \vert \vee 1 } \right] \le q .
+$$
+
+# 4 KNOCKOFFGAN
+
+It should be noted that in order to satisfy equation (2), it simply needs to be the case that the knockoffs are constructed without looking at the label, $Y$ . In order to satisfy equation (1) we use a modified GAN framework, which gives us the flexibility to learn to generate knockoffs without any assumptions on the distribution of the original features.
+
+![](images/076b75a474ceff85d4dade22b0c91f60bd64599537e723b26977e580baabe05c.jpg)  
+Figure 1: KnockoffGAN Block Diagram
+
+# 4.1 GENERATOR
+
+The generator, $G$ , will be a function $G ( \cdot , \cdot ; \phi ) : \mathcal { X } \times [ 0 , 1 ] ^ { c } \to \mathcal { X }$ , parametrized by $\phi$ that takes a realization $\mathbf { x }$ of $\mathbf { X }$ and random noise, $\mathbf { z } \sim \mathcal { U } ( [ 0 , 1 ] ^ { c } )$ , as inputs and outputs knockoff features $\tilde { \bf x }$ . We define $\tilde { \mathbf { X } } : = G ( \mathbf { X } , \mathbf { z } )$ . We model $G$ as a fully connected neural network with weights $\phi$ .
+
+# 4.2 DISCRIMINATOR
+
+The main innovation of our paper is in defining the discriminator. Equation (1) imposes a condition on the joint distribution of $( \bar { \bf X } , \tilde { \bf X } )$ and as such we must define a discriminator with a loss that is (not necessarily uniquely) minimized only for joint distributions satisfying this condition. To that end, the discriminator, $D$ , will be a function $\overset { \cdot } { D } ( \cdot ; \psi ) : \overset { \cdot } { \chi } \times \overset { \chi } { \chi }  \overset { \cdot } { [ 0 , \overset { . } { . } ] } ^ { d }$ that takes as input a swapped sample-knockoff pair $( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S ) }$ and outputs a vector in $[ 0 , 1 ] ^ { d }$ with the $i$ th component of $D ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S ) } )$ corresponding to the probability that $i \in S$ . The discriminator is attempting to detect which variables have been swapped and, intuitively, when the discriminator is unable to determine this, the swapped and unswapped joint distributions must be the same.
+
+The loss we use to train the discriminator is the multi-output cross-entropy loss given by
+
+$$
+\mathcal { L } _ { D } = \sum _ { \mathbf { S } \in \{ 0 , 1 \} ^ { d } } \mathbb { E } _ { \mathbf { X } \sim \mathcal { P } _ { \mathbf { X } } } [ \mathbb { E } _ { { \tilde { \mathbf { X } } } \sim \mathcal { P } _ { \mathbf { X } } ( \mathbf { X } ) } [ \mathbf { S } \cdot \log ( D ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) _ { \operatorname { s w a p } ( S ) } ) ) + ( \mathbf { 1 } - \mathbf { S } ) \cdot \log ( 1 - D ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) _ { \operatorname { s w a p } ( S ) } ) ) ]
+$$
+
+where $\cdot$ is the standard dot, $\mathbf { 1 } = ( 1 , . . . , 1 )$ , $\mathbf { S } = ( S _ { 1 } , . . . , S _ { d } )$ with $S _ { i } = \mathbb { I } ( i \in S )$ $\mathbb { I }$ is the indicator function) and $\log$ is taken element-wise. The following theorem is our main theoretical result, which states that the training regime employed by KnockoffGAN will result in a procedure that generates valid knockoffs.
+
+Theorem 2. Equation (4) is maximized (with respect to $G$ ) if and only if equation $( l )$ is satisfied by $G$ .
+
+Proof. The proof, alongside supporting theoretical results, can be found in the Appendix.
+
+In practice, the sum is too computationally expensive $( O ( 2 ^ { d } ) )$ to calculate and so we perform stochastic gradient descent using minibatches with S sampled uniformly from $\{ 0 , 1 \} ^ { d }$ , independently for each sample in the minibatch.
+
+We also found that training with respect to the full loss resulted in a poor performance, particularly when $d$ is large. We found that the discriminator struggled to learn anything when asked to find the full swap vector, and the poor discriminator resulted in a poorly trained generator. In order to overcome this, we introduce a hint vector - first introduced in [38] - that we use to reveal partial information to the discriminator about the swap vector. We do this by using the hint to reveal some, but not all, of the components of $S$ to the discriminator. In doing so, we reduce the burden of the discriminator from needing to determine the entire swap vector to only needing to determine some of the swap vector.
+
+Formally, the hint, $\mathbf { H }$ , will be a random variable depending on S, that we pass to the discriminator, alongside $( \mathbf { X } , \tilde { \mathbf { X } } ) _ { \mathrm { s w a p } ( S ) }$ . We use the hint to control the amount of information we pass to $D$ about S before asking $D$ to predict S. In practice, our hinting mechanism involves sampling a multivariate Bernoulli random variable, $\mathbf { B }$ from i.i.d. components, which each take value 1 with probability 0.9. The hint is then constructed by setting $H _ { i } = S _ { i }$ if $B _ { i } = 1$ and $H _ { i } = 0 . 5$ if $B _ { i } = 0$ . The discriminator is therefore being asked only to predict the values of S for which $B _ { i } = 0$ ; the others, $D$ is able to directly infer from $H _ { i }$ . In order to avoid overfitting to the hint, it becomes necessary to remove these terms from our loss. Our loss now becomes
+
+$$
+\begin{array} { r } { \mathcal { L } _ { D } = \displaystyle \sum _ { \mathbf { S } \in \{ 0 , 1 \} ^ { d } } \mathbb { E } _ { \mathbf { X } \sim \mathcal { P } _ { \mathbf { X } } } [ \mathbb { E } _ { { \bar { \mathbf { X } } } \sim \mathcal { P } _ { \mathbf { X } } ( \mathbf { X } ) } [ \mathbb { E } _ { \mathbf { H } \sim \mathcal { P } _ { \mathbf { H } | \mathbf { S } } } [ ( \mathbf { S } \odot ( \mathbf { 1 } - \mathbf { B } ) ) \cdot \log ( D ( ( \mathbf { X } , { \bar { \mathbf { X } } } ) _ { \mathrm { s w a p } ( S ) } , \mathbf { H } ) )     (  \mathbb { E } _ { \mathbf { X } \sim \mathcal { P } _ { \mathbf { X } } ( \mathbf { X } ) } [ ( \mathbf { X } \sim \mathbf { H } ) \cdot \mathbf { H } _ { \mathbf { H } \sim \mathbf { H } } ( \mathbf { X } ) \cdot \mathbf { H } _ { \mathbf { H } } ( \mathbf { X } ) \cdot \mathbf { H } _ { \mathbf { H } } ( \mathbf { X } ) ] ]   } \\ {   +  ( ( \mathbf { 1 } - \mathbf { S } ) \odot ( \mathbf { 1 } - \mathbf { B } ) ) \cdot \log ( 1 - D ( ( \mathbf { X } , { \bar { \mathbf { X } } } ) _ { \mathrm { s w a p } ( S ) } , \mathbf { H } ) ) ] ] ] } \end{array}
+$$
+
+where $\odot$ denotes element-wise multiplication and the expectation over $\mathbf { B }$ is implicit in the expectation over $\mathbf { H }$ .
+
+# 4.3 STABILITY
+
+We found that adding a regularization term in the form of a Wasserstein GAN discriminator (with Gaussian Process (GP) regularization) [2], $f$ , aided performance. We note that when equation (1) holds, we must have that ${ \bf x } \ { \overset { d . } { = } } \ { \tilde { \bf X } }$ and so the addition of this regularizing term does not affect the optimal solution to our loss. We model $f$ as a fully connect neural network with weights $\nu$ . The loss is given by
+
+$$
+\mathcal { L } _ { f } = \mathbb { E } \left[ f ( \mathbf { X } ) - f ( \tilde { \mathbf { X } } ) - \eta ( | | \nabla _ { \hat { \mathbf { X } } } f ( \hat { \mathbf { X } } ) | | _ { 2 } - 1 ) ^ { 2 } \right]
+$$
+
+where $\epsilon \sim \mathcal { U } [ 0 , 1 ]$ , $\hat { \mathbf { X } } = \epsilon \mathbf { X } + ( 1 - \epsilon ) \tilde { \mathbf { X } }$ and $\eta$ is a hyper-parameter (set to 10 in practice). Note that we have rewritten the loss to be the negative of the one given in [2], allowing us to write our overall objective as a minimax problem. This loss is added to the generator loss as an additional regularization term.
+
+# 4.4 MAXIMIZING POWER
+
+As noted in [7], it is intuitive that in order to maximize the power of the knockoff selection procedure, we wish to make $X _ { j }$ and $\tilde { X } _ { j }$ as ”independent” as possible. Doing so ensures that as little as possible of the dependence between the real feature and the label is present between the knockoff and the label; this allows us to determine whether or not the relationship between the feature and label is only through the feature’s correlation with other features, or is in fact a true signal.
+
+In order to achieve maximal independence, we look to minimize the mutual information between each feature and its knockoff. Actually computing the true mutual information requires access to both the joint density of the feature-knockoff pairs and to the marginal densities of each feature and knockoff, which we do not have.
+
+Instead, we look to a promising recent work, Mutual Information Neural Estimation (MINE [4]), that provides a framework for estimating the mutual information using neural networks. To do so, they estimate the mutual information between random variables $U$ and $V$ by performing gradient ascent on the following objective:
+
+$$
+\operatorname* { s u p } _ { \theta \in \Theta } \mathbb { E } _ { \mathbb { P } _ { U V } ^ { ( n ) } } [ T _ { \theta } ] - \log ( \mathbb { E } _ { \mathbb { P } _ { U } ^ { ( n ) } \otimes \mathbb { P } _ { V } ^ { ( n ) } } [ e ^ { T _ { \theta } } ] )
+$$
+
+where $\mathbb { P } _ { U V }$ denotes the joint measure of $( U , V )$ with $\begin{array} { r } { \mathbb { P } _ { U } = \int _ { \mathcal { V } } d \mathbb { P } _ { U V } } \end{array}$ and $\begin{array} { r } { \mathbb { P } _ { V } = \int _ { \mathcal { U } } d \mathbb { P } _ { U V } } \end{array}$ denoting the marginal measures. $( n )$ denotes the empircal distribution associated with $n$ i.i.d. samples.
+
+Using MINE we approximate the mutual information between each pair $X _ { j }$ and $\tilde { X } _ { j }$ by using $d$ neural networks1, $T ^ { 1 } , . . . , T ^ { d }$ , each parametrized by $\theta _ { 1 } , . . . , \theta _ { d }$ , that we refer to collectively as the power network, and will write $P$ to denote the collection of networks $T ^ { 1 } , . . . , T ^ { d }$ . The mutual information is added using a trade-off parameter $\lambda$ to the loss for $G$ . Formally, define $\mathcal { L } _ { P }$ by
+
+$$
+\mathcal { L } _ { P } = \sum _ { j = 1 } ^ { d } \left( \sum _ { i = 1 } ^ { n } ( T _ { \theta _ { j } } ^ { j } ( x _ { j } ^ { ( i ) } , \tilde { x } _ { j } ^ { ( i ) } ) ) - \log ( \sum _ { i = 1 } ^ { n } \exp ( T _ { \theta _ { j } } ^ { j } ( x _ { j } ^ { ( \kappa ( i ) ) } , \tilde { x } _ { j } ^ { ( i ) } ) ) ) \right)
+$$
+
+where $\kappa$ is a random permutation of $[ n ] ^ { 2 }$ and $( i )$ denotes the ith sample - noting that dependence on $G$ is through $\tilde { \mathbf { X } }$ .
+
+# 4.5 FINAL OBJECTIVE
+
+The resulting minimax game played by $G , D , W$ and $P$ is given by
+
+$$
+\operatorname* { m i n } _ { G } \left( \operatorname* { m a x } _ { D } ( \mathcal { L } _ { D } ) + \lambda \operatorname* { m a x } _ { P } ( \mathcal { L } _ { P } ) + \mu \operatorname* { m a x } _ { f } ( \mathcal { L } _ { f } ) \right)
+$$
+
+where $\lambda , \mu$ are hyper-parameters (set to 1 in the experiments section).
+
+We train each of $G , D , W$ and $P$ iteratively. Pseudo-code of our knockoff construction algorithm can be found in Algorithm 1 and a visual representation of our architecture in Fig. 1.
+
+After generating knockoffs, feature statistics are computed according to some procedure (in the synthetic experiments we use LASSO and in the real data experiment we use a Random Forestbased statistic [37]). Features are then selected based on these statistics according to Theorem 1.
+
+# 5 EXPERIMENTS
+
+In this section we demonstrate the capability of our method to match the results of [7] in settings where their model is correctly specified (i.e. when the underlying feature distribution is Gaussian) and then go on to show, in settings where the underlying feature distribution is non-Gaussian, that our method is able to outperform their Gaussian approximation. We compare to two versions of the BHq method [5; 6] to provide a baseline.
+
+We also perform a qualitative analysis of KnockoffGAN on a real-world dataset. We compare features found by KnockoffGAN to PubMed literature and show that KnockoffGAN discovers several meaningful features for 2 different disease outcomes.
+
+# Algorithm 1 Pseudo-code of KnockoffGAN
+
+1: Inputs: mini-batch size $n _ { m b } > 0$ , Initialize parameters $\phi , \psi , \nu , \theta _ { 1 } , . . . , \theta _ { d }$   
+2: while Converge do   
+3: Discriminator Update   
+4: Sample $\mathbf { x } _ { 1 } , . . . , \mathbf { x } _ { n _ { m b } }$ from D $\mathbf { \Sigma } ) , \mathbf { z } _ { 1 } , . . . , \mathbf { z } _ { n _ { m b } } \sim \mathbb { P } _ { Z }$   
+5: Sample $\mathbf { S } _ { 1 } , . . . , \mathbf { S } _ { n _ { m b } } \overset { i . i . d } { \sim } \mathcal { U } ( \{ 0 , 1 \} ^ { d } ) , \mathbf { b } _ { 1 } , . . . , \mathbf { b } _ { n _ { m b } } \sim \mathbf { B e r } ( 0 . 9 )$   
+6: for $i = 1 , . . . , n _ { m b }$ do   
+7: x˜i ← G(xi, zi; φ)   
+8: $\mathbf { h } _ { i } = \mathbf { S } _ { i } \odot \mathbf { b } _ { i } + 0 . 5 ( \mathbf { 1 } - \mathbf { b } _ { i } )$
+
+9: Update $D$ by ascending its stochastic gradient
+
+$$
+\begin{array} { r l } {  { \nabla _ { \psi } \sum _ { i = 1 } ^ { n _ { m b } } \Big [ \big ( \mathbf S _ { i } \odot ( \mathbf 1 - \mathbf b _ { i } ) \big ) \cdot \log \big ( D \big ( ( \mathbf x _ { i } , \tilde { \mathbf x } _ { i } ) _ { \mathrm { s w a p } ( \mathbf S ) } \big ) , \mathbf h _ { i } \big ) } \quad } & { } \\ & { \qquad + ( ( \mathbf 1 - \mathbf S _ { i } ) \odot ( \mathbf 1 - \mathbf b _ { i } ) ) \cdot \log \big ( \mathbf 1 - D \big ( ( \mathbf x _ { i } , \tilde { \mathbf x } _ { i } ) _ { \mathrm { s w a p } ( \mathbf S ) } , \mathbf h _ { i } \big ) \big ) \Big ] } \end{array}
+$$
+
+# 10: MINE Update
+
+11: Sample $\mathbf { x } _ { 1 } , . . . , \mathbf { x } _ { n _ { m b } }$ from $\mathcal { D } , \mathbf { z } _ { 1 } , . . . , \mathbf { z } _ { n _ { m b } } \sim \mathbb { P } _ { Z }$ , $\kappa \sim \mathcal { U } ( S _ { n _ { m b } } )$   
+12: for $i = 1 , . . . , n _ { m b }$ do   
+13: $\tilde { \mathbf { x } } _ { i } \gets G ( \mathbf { x } _ { i } , \mathbf { z } _ { i } ; \phi )$   
+14: for $j = 1 , . . . , d$ do   
+15: Update $T _ { j }$ by ascending its stochastic gradient   
+$\begin{array} { r } { \nabla _ { \theta _ { j } } \Big ( \sum _ { i = 1 } ^ { n _ { m b } } T _ { \theta _ { j } } ^ { j } ( x _ { j } ^ { ( i ) } , \tilde { x } _ { j } ^ { ( i ) } ) \Big ) - \log \Big ( \sum _ { i = 1 } ^ { n _ { m b } } \exp ( T _ { \theta _ { j } } ^ { j } ( x _ { j } ^ { ( i ) } , \tilde { x } _ { j } ^ { ( \kappa ( i ) ) } ) ) \Big ) } \end{array}$
+
+# 16: WGAN-GP Update
+
+17: Sample $\mathbf { x } _ { 1 } , . . . , \mathbf { x } _ { n _ { m b } }$ from $D , \mathbf { z } _ { 1 } , . . . , \mathbf { z } _ { n _ { m b } } \sim \mathbb { P } _ { Z }$   
+18: for $i = 1 , . . . , n _ { m b }$ do   
+19: Sample $\epsilon \sim \mathcal { U } [ 0 , 1 ]$   
+20: $\begin{array} { r l } & { \tilde { \mathbf { x } } _ { i }  G ( \mathbf { x } _ { i } , \mathbf { z } _ { i } ; \boldsymbol { \phi } ) ^ { \cdot } } \\ & { \hat { \mathbf { x } } _ { i } = \epsilon \mathbf { x } _ { i } + ( 1 - \epsilon ) \tilde { \mathbf { x } } _ { i } } \end{array}$   
+21:
+
+22: Update $f$ by ascending its stochastic gradient
+
+$$
+\begin{array} { r } { \nabla _ { \nu } \sum _ { i = 1 } ^ { n _ { m b } } \left[ f ( \mathbf { x } _ { i } ) - f ( \tilde { \mathbf { x } } _ { i } ) - \eta ( | | \nabla _ { \hat { \mathbf { x } } _ { i } } f ( \hat { \mathbf { x } } _ { i } ) | | _ { 2 } - 1 ) ^ { 2 } \right] } \end{array}
+$$
+
+# 23: Generator Update
+
+24: Sample $\mathbf { x } _ { 1 } , . . . , \mathbf { x } _ { n _ { m b } }$ from D, z1, ..., znmb ∼ PZ   
+25: Sample S1, ..., Snmb $\mathbf { S } _ { 1 } , . . . , \mathbf { S } _ { n _ { m b } } \overset { i . i . d } { \sim } \mathcal { U } ( \{ 0 , 1 \} ^ { d } ) , \kappa \sim \mathcal { U } ( S _ { n _ { m b } } )$   
+26: for $i = 1 , . . . , n _ { m b }$ do   
+27: $\tilde { \mathbf { x } } _ { i }  G ( \mathbf { x } _ { i } , \mathbf { z } _ { i } ; \phi )$   
+28: Update $G$ by descending its stochastic gradient
+
+$$
+\nabla _ { \phi } ( \mathcal { L } _ { D } + \lambda \mathcal { L } _ { P } + \mu \mathcal { L } _ { f } )
+$$
+
+# 5.1 SYNTHETIC DATA EXPERIMENTS
+
+# 5.1.1 SIMULATION SETTINGS
+
+Evaluating feature selection methods on real data is difficult as we do not have access to the ground truth. To evaluate KnockoffGAN, we conduct a series of experiments using synthetic data, replicating those carried out in [7] and extending them to more general settings. In each of the following synthetic experiments, we set the feature dimension to be $d = 1 0 0 0$ and the number of samples to be $n = 3 0 0 0$ . For each feature distribution we perform two experiments:
+
+1. Y-Logit: P (Y = 1|X) = exp(m(X))(1+exp(m(X)))   
+2. Y-Gaussian: $Y \sim \mathcal { N } ( m ( \mathbf { X } ) , 1 )$
+
+where $\begin{array} { r } { m ( \mathbf { X } ) = \sum _ { i = 1 } ^ { 6 0 } \alpha \delta _ { i } X _ { i } } \end{array}$ with $\delta _ { i } \in \{ - 1 , 1 \}$ sampled uniformly and then fixed for each experiment. $\alpha$ controls the strength of the influence that $\mathbf { X }$ has on $Y$ , and in the experiments we vary this (as in [7]). Note that for the auto-regressive settings (found in Section 5.1.2 and the Appendix) the relevant variables are sampled uniformly at random from among the 1000 features (rather than being the first 60); in the non-auto-regressive settings this is not necessary.
+
+We report the True Positive Rate (TPR), which is also commonly referred to as the power, defined as
+
+$$
+\mathrm { T P R } = \frac { | \hat { S } \cap S ^ { * } | } { | S ^ { * } | }
+$$
+
+where $S ^ { * } = \left\{ 1 , . . . , d \right\} \backslash \mathcal { H } _ { 0 }$ is the set of all non-null features. We also report the FDR to verify that the methods do indeed control it at the specified level which we set to be $10 \%$ . Note that we are not using FDR as a metric - a lower FDR is not desirable when we set the threshold to $10 \%$ . In fact, we want the methods to be as close to $10 \%$ as possible (so that they are achieving maximum power). We perform 100 replications of each experiment and report the average TPR and FDR.
+
+# 5.1.2 GAUSSIAN SETTINGS
+
+We begin by replicating the setup from [7] in which the underlying feature distribution is Gaussian. In this setting, we do not expect KnockoffGAN to perform better than the original knockoff framework as the original framework assumes a Gaussian distribution. Our goal here is simply to achieve a similar performance, demonstrating that little performance is lost even when the distribution is known to be Gaussian.
+
+In the first experiment that we replicate from [7], the features are set to be auto-regressive (AR(1)) with Gaussian marginal distributions, i.e. $X _ { i } = \phi X _ { i - 1 } + Z _ { i }$ with $Z _ { i }$ being chosen such that $X _ { i } \stackrel { i . i . d } { \sim }$ . $\textstyle { \mathcal { N } } ( 0 , { \frac { 1 } { n } } )$ . In this experiment we vary $\phi$ , which determines the correlation between features, rather than $\alpha$ . We fix $\alpha = 3 . 5$ for Y-Gaussian and $\alpha = 1 0$ for Y-Logit. The results are reported in Fig. 2.
+
+![](images/de67f3a4834bf33ac0fefdee1163e31add7f7c0dfae404049379b604f5a91a36.jpg)  
+Figure 2: Comparison of KnockoffGAN with the benchmarks for X distributed as an auto-regressive distribution with Gaussian marginal distributions. TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+As in [7], we observe that BHq Marginal, which tests for marginal independence of the feature from $Y$ , suffers from severely increased FDR as we increase the correlation, invalidating the seemingly good TPR. To make the remaining results clearer, we omit $\mathrm { B H q }$ marginal from the rest of this section. Aside from this, we see in Fig. 2, that the other methods control the FDR at or very close to the specified $10 \%$ threshold. We also see that across the entire range of $\alpha$ , KnockoffGAN achieves a very similar TPR to the original Knockoff framework.
+
+In the second experiment, we set the underlying feature distribution to be i.i.d. Gaussian. We found in this case also that KnockoffGAN was able to control the FDR and achieve a similar TPR to the original knockoff framework. More details of this experiment and the results for it can be found in the Appendix
+
+# 5.1.3 NON-GAUSSIAN SETTINGS
+
+We now move on to the key results for the paper in which the underlying feature distribution is no longer Gaussian. In this setting, we expect to outperform the original Knockoff framework due to the fact that they approximate the distribution as Gaussian. In particular, when this approximation is poor, the knockoffs are no longer valid and as such no FDR guarantees can be given. On the other hand, KnockoffGAN does not place any requirements on the distribution of the features and as such is able to generate valid knockoffs.
+
+We performed experiments for several different underlying feature distributions, and found that KnockoffGAN achieved a higher TPR than the original knockoff framework in all cases, while controlling the FDR at the specified level. We give the results for $\mathbf { X }$ coming from a 4-Gaussian mixture model in Fig. 3 - results for Uniform, Dirichlet, and other (2 and 3) Gaussian mixture models can be found in the Appendix.
+
+To create our 4-mixture model, we set the means $( \mathbf { m } ^ { 1 } , \mathbf { m } ^ { 2 } , \mathbf { m } ^ { 3 } , \mathbf { m } ^ { 4 } )$ of the 4 Gaussians to be:
+
+• $m _ { i } ^ { 1 } = 1$ for $i = 1$ to 100 and 0 for $i = 1 0 1$ to 1000,   
+• $m _ { i } ^ { 2 } = 1$ for $i = 1$ to 50 and $^ { - 1 }$ for $i = 5 1$ to 100 and 0 for $i = 1 0 1$ to 1000, • $m _ { i } ^ { 3 } = - 1$ for $i = 1$ to 50 and 1 for $i = 5 1$ to 100 and 0 for $i = 1 0 1$ to 1000, • $m _ { i } ^ { 4 } = - 1$ for $i = 1$ to 100 and 0 for $i = 1 0 1$ to 1000.
+
+We scale the variance of each Gaussian to be such that the overall variance of each feature is $\textstyle { \frac { 1 } { n } }$
+
+![](images/60afb230e8548471f1ce64f2ff890f1aa8a00415b1c9bb8ec7f2c355f0e8798d.jpg)  
+Figure 3: Comparison of KnockoffGAN with the benchmarks for $\mathbf { X }$ distributed as a 4-mixture Gaussian mixture model. TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+We see in Fig. 3 that KnockoffGAN consistently outperforms the original knockoff framework, achieving a higher TPR across the entire range of $\alpha$ while consistently controlling the FDR at $10 \%$ . In fact, in the $Y$ -Gaussian setting we see that the original knockoff framework performs almost identically to BHq Maximum Likelihood.
+
+# 5.1.4 IMPACT OF WGAN REGULARIZATION
+
+We conclude the synthetic experiments by demonstrating the effect of the WGAN regularizer3. We conduct this experiment using an auto-regressive model with $\mathcal { U } ( - \sqrt { 3 / n } , \sqrt { 3 / n } )$ marginal distributions. We fix $\alpha = 5$ for Y-Logit and $\alpha = 2 . 5$ for Y-Gauss.
+
+![](images/b41a740dc31dab3932212f0229bb3470fbf52705cb2e7ae842a87504400d808c.jpg)  
+Figure 4: A comparison of the performance of KnockoffGAN with and without the WGAN regularizer for $\mathbf { X }$ distributed as an auto-regressive distribution with $\mathcal { U } ( - \sqrt { 3 / n } , \sqrt { 3 / n } )$ marginal distributions. TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+As we see in Fig. 4, the WGAN regularizer has a significant effect on the results, with the improvement in some places being almost as much as KnockoffGAN without WGAN makes over the original knockoff framework. As noted in Section 4.3, there is no trade-off introduced by the inclusion of this regularizer; the optimal solution to the loss is unchanged and therefore this regularization is ”free” in terms of FDR control, but as demonstrated improves TPR performance.
+
+# 5.2 REAL DATA EXPERIMENT
+
+In this section we use a biobank dataset (with 387 dimensions) to qualitatively analyze the performance of KnockoffGAN. We use KnockoffGAN to select features for two different outcomes: (1) Cardiovascular Disease (CVD) and (2) Diabetes and then use PubMed literature to asses the validity of the selected features.
+
+We found that the original knockoff framework was unable to select even the most well-known features (such as Age and Sex for CVD [15]), even when the FDR threshold was increased to $20 \%$ . Therefore, there are no relevant features to report for the original knockoff framework and so Table 1 contains only the features selected by KnockoffGAN that were deemed relevant by PubMed literature. For this the FDR threshold was set to $5 \%$ so that the number of discoveries was manageable for cross-reference with PubMed.
+
+<table><tr><td>No</td><td>Cardiovascular Disease</td><td>PubMed ref.</td><td>Diabetes</td><td>PubMed ref.</td></tr><tr><td>1 2</td><td>Age Sex</td><td>[15]</td><td>Lipid-lowering drugs</td><td>[35]</td></tr><tr><td></td><td>Daily smoking</td><td>[15] [1]</td><td>Comparative body size Home owned</td><td>[27]</td></tr><tr><td>３４</td><td>FEV1</td><td>[28]</td><td>Insomnia</td><td>[13]</td></tr><tr><td>5</td><td></td><td></td><td></td><td>[34]</td></tr><tr><td></td><td>Diastolic blood pressure</td><td>[33]</td><td>Anti-hypertensive drugs</td><td>[8]</td></tr><tr><td>6</td><td>Diabetes</td><td>[29]</td><td>Asthma</td><td>[30]</td></tr><tr><td>7</td><td>Father chronic bronchitis</td><td>[14; 23]</td><td>Height</td><td>[19;27]</td></tr><tr><td>8</td><td>Alcohol intake</td><td>[21]</td><td>Alcohol intake</td><td>[36]</td></tr><tr><td>9</td><td>Long-standing illness</td><td></td><td></td><td></td></tr></table>
+
+Table 1: Discovered features using KnockoffGAN framework, verified using PubMed literature. The FDR threshold was set to $5 \%$ .
+
+As we see in Table 1, KnockoffGAN discovers 9 relevant features for CVD and 8 relevant features for diabetes. Some of the relevant features, such as Age, Sex and Long-standing illness for CVD are well-known relevant features. The remaining features are all supported by the literature in PubMed. While this is a qualitative result (it relies on using PubMed as the ground truth), we do believe this demonstrates that KnockoffGAN is a significant improvement over the original knockoff generation procedure.
+
+# 6 CONCLUSION
+
+In this paper we built on the knockoff framework introduced in [3] by developing a novel GAN framework, KnockoffGAN, capable of generating knockoffs with no assumptions on the underlying data. We demonstrated through a series of experiments on a range of synthetic datasets and on a real world dataset that our method improves on the performance of the original knockoff framework.
+
+While we feel this is a significant step towards being able to generate knockoffs for any data, there is still more work to be done. In particular, generalizing this method to time-series data would be non-trivial, and would be an interesting avenue for further investigation.
+
+# ACKNOWLEDGEMENT
+
+The authors would like to thank the reviewers for their helpful comments. The research presented in this paper was supported by the Office of Naval Research (ONR) and the NSF (Grant number: ECCS1462245, ECCS1533983, and ECCS1407712).
+
+# REFERENCES
+
+[1] John A Ambrose and Rajat S Barua. The pathophysiology of cigarette smoking and cardiovascular disease: an update. Journal of the American college of cardiology, 43(10):1731–1737, 2004.   
+[2] Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein gan. ´ arXiv preprint arXiv:1701.07875, 2017.   
+[3] Rina Foygel Barber and Emmanuel J Candes. A knockoff filter for high-dimensional selective inference. arXiv preprint arXiv:1602.03574, 2016.   
+[4] Mohamed Ishmael Belghazi, Aristide Baratin, Sai Rajeshwar, Sherjil Ozair, Yoshua Bengio, Devon Hjelm, and Aaron Courville. Mutual information neural estimation. In Proceedings of the 35th International Conference on Machine Learning, pp. 530–539, 2018.   
+[5] Yoav Benjamini and Yosef Hochberg. Controlling the false discovery rate: a practical and powerful approach to multiple testing. Journal of the royal statistical society. Series B (Methodological), pp. 289–300, 1995.   
+[6] Yoav Benjamini and Daniel Yekutieli. The control of the false discovery rate in multiple testing under dependency. Annals of statistics, pp. 1165–1188, 2001.   
+[7] Emmanuel Candes, Yingying Fan, Lucas Janson, and Jinchi Lv. Panning for gold: \` Model-free knockoffs for high-dimensional controlled variable selection. arXiv preprint arXiv:1610.02351, 2016.   
+[8] Antonio Ceriello, Dario Giugliano, Antonio Quatraro, and Pierre J Lefebvre. Anti-oxidants show an anti-hypertensive effect in diabetic and hypertensive subjects. Clinical Science, 81(6): 739–742, 1991.   
+[9] Yingying Fan, Emre Demirkaya, Gaorong Li, and Jinchi Lv. Rank: large-scale inference with graphical nonlinear knockoffs. arXiv preprint arXiv:1709.00092, 2017.   
+[10] Jaime Roquero Gimenez, Amirata Ghorbani, and James Zou. Knockoffs for the mass: new feature importance statistics with false discovery guarantees. arXiv preprint arXiv:1807.06214, 2018.   
+[11] 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.   
+[12] Isabelle Guyon and Andre Elisseeff. An introduction to variable and feature selection. ´ Journal of machine learning research, 3(Mar):1157–1182, 2003.   
+[13] C Jaffiol, F Thomas, K Bean, B Jego, and N Danchin. Impact of socioeconomic status on dia- ´ betes and cardiovascular risk factors: results of a large french survey. Diabetes & metabolism, 39(1):56–62, 2013.   
+[14] Pekka Jousilahti, Erkki Vartiainen, Jaakko Tuomilehto, and Pekka Puska. Symptoms of chronic bronchitis and the risk of coronary disease. The Lancet, 348(9027):567–572, 1996.   
+[15] Pekka Jousilahti, Erkki Vartiainen, Jaakko Tuomilehto, and Pekka Puska. Sex, age, cardiovascular risk factors, and coronary heart disease: a prospective follow-up study of 14 786 middle-aged men and women in finland. Circulation, 99(9):1165–1172, 1999.   
+[16] Alan Jovic, Karla Brki ´ c, and Nikola Bogunovi ´ c. A review of feature selection methods with ´ applications. In Information and Communication Technology, Electronics and Microelectronics (MIPRO), 2015 38th International Convention on, pp. 1200–1205. IEEE, 2015.   
+[17] Alan Jovic, Karla Brki ´ c, and Nikola Bogunovi ´ c. A review of feature selection methods with ´ applications. In Information and Communication Technology, Electronics and Microelectronics (MIPRO), 2015 38th International Convention on, pp. 1200–1205. IEEE, 2015.   
+[18] Eugene Katsevich and Chiara Sabatti. Multilayer knockoff filter: Controlled variable selection at multiple resolutions. arXiv preprint arXiv:1706.09375, 2017.   
+[19] D Lawlor, S Ebrahim, and G Davey Smith. The association between components of adult height and type ii diabetes and insulin resistance: British women’s heart and health study. Diabetologia, 45(8):1097–1106, 2002.   
+[20] Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro ´ Acosta, Andrew P Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, et al. Photo-realistic single image super-resolution using a generative adversarial network. In CVPR, volume 2, pp. 4, 2017.   
+[21] Michael Marmot and Eric Brunner. Alcohol and cardiovascular disease: the status of the u shaped curve. BMJ: British Medical Journal, 303(6802):565, 1991.   
+[22] Tahir Mehmood, Kristian Hovde Liland, Lars Snipen, and Solve Sæbø. A review of variable selection methods in partial least squares regression. Chemometrics and Intelligent Laboratory Systems, 118:62–69, 2012.   
+[23] Howraman Meteran, Vibeke Backer, Kirsten Ohm Kyvik, Axel Skytthe, and Simon Francis Thomsen. Heredity of chronic bronchitis: a registry-based twin study. Respiratory medicine, 108(9):1321–1326, 2014.   
+[24] Sebastian Nowozin, Botond Cseke, and Ryota Tomioka. f-gan: Training generative neural samplers using variational divergence minimization. In Advances in Neural Information Processing Systems, pp. 271–279, 2016.   
+[25] Carl Rietschel, Jinsung Yoon, and Mihaela van der Schaar. Feature selection for survival analysis with competing risks using deep learning. arXiv preprint arXiv:1811.09317, 2018.   
+[26] Matteo Sesia, Chiara Sabatti, and Emmanuel J Candes. Gene hunting with knockoffs for \` hidden markov models. arXiv preprint arXiv:1706.04677, 2017.   
+[27] Suzanne M Shoff and Polly A Newcomb. Diabetes, body size, and risk of endometrial cancer. American journal of epidemiology, 148(3):234–240, 1998.   
+[28] Don D Sin and SF Paul Man. Chronic obstructive pulmonary disease: a novel risk factor for cardiovascular disease. Canadian journal of physiology and pharmacology, 83(1):8–13, 2005.   
+[29] James R Sowers and Melvin A Lester. Diabetes and cardiovascular disease. Diabetes care, 22: C14, 1999.   
+[30] Lars C Stene and Per Nafstad. Relation between occurrence of type 1 diabetes and asthma. The Lancet, 357(9256):607–608, 2001.   
+[31] Jiliang Tang, Salem Alelyani, and Huan Liu. Feature selection for classification: A review. Data classification: Algorithms and applications, pp. 37, 2014.   
+[32] Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), pp. 267–288, 1996.   
+[33] Ramachandran S Vasan, Martin G Larson, Eric P Leip, Jane C Evans, Christopher J O’donnell, William B Kannel, and Daniel Levy. Impact of high-normal blood pressure on the risk of cardiovascular disease. New England journal of medicine, 345(18):1291–1297, 2001.   
+[34] Alexandros N Vgontzas, Duanping Liao, Slobodanka Pejovic, Susan Calhoun, Maria Karataraki, and Edward O Bixler. Insomnia with objective short sleep duration is associated with type 2 diabetes: a population-based study. Diabetes care, 2009.   
+[35] Sandeep Vijan and Rodney A Hayward. Pharmacologic lipid-lowering therapy in type 2 diabetes mellitus: background paper for the american college of physicians. Annals of Internal Medicine, 140(8):650–658, 2004.   
+[36] SG Wannamethee, AG Shaper, IJ Perry, and KGMM Alberti. Alcohol consumption and the incidence of type ii diabetes. Journal of Epidemiology & Community Health, 56(7):542–548, 2002.   
+[37] Marvin N Wright, Theresa Dankowski, and Andreas Ziegler. Unbiased split variable selection for random survival forests using maximally selected rank statistics. Statistics in medicine, 36 (8):1272–1284, 2017.   
+[38] Jinsung Yoon, James Jordon, and Mihaela van der Schaar. GAIN: Missing data imputation using generative adversarial nets. In Proceedings of the 35th International Conference on Machine Learning, pp. 5689–5698, 2018.
+
+# APPENDIX
+
+# THEORETICAL RESULTS
+
+In order to prove Theorem 2, we use similar techniques to those used in the original GAN paper [11]. In what follows, we analyze the minimax game defined by:
+
+$$
+\operatorname* { n i n } _ { G } \operatorname* { m a x } _ { D } \sum _ { \mathbf { S } \in \{ 0 , 1 \} ^ { d } } \mathbb { E } _ { \mathbf { X } \sim \mathcal { P } _ { \mathbf { X } } } [ \mathbb { E } _ { { \bar { \mathbf { X } } } \sim \mathcal { P } _ { \mathbf { X } } ( \mathbf { X } ) } [ \mathbf { S } \cdot \log ( D ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) _ { \operatorname { s w a p } ( S ) } ) ) + ( \mathbf { 1 } - \mathbf { S } ) \cdot \log ( 1 - D ( ( \mathbf { X } , { \tilde { \mathbf { X } } } ) _ { \operatorname { s w a p } ( S ) } ) ) ] ]
+$$
+
+where we have used the version of $\mathcal { L } _ { D }$ given by equation (4) in the main manuscript (i.e. without hinting). The theoretical results that follow are proven only for this version of the loss, though we do believe that the theorem holds more generally for the hinting version of the loss - this is backed up by our empirical results demonstrating strict FDR control while using the hint mechanism. After proving that the optimal solution to this game does indeed provide us with valid knockoffs, we will then show that the additional term $\mathcal { L } _ { f }$ does not change the optimal solution. Let $p$ be the density of $( \mathbf { X } , \tilde { \mathbf { X } } )$ .
+
+We begin by stating a lemma, that follows from a similar proof to Proposition 1 in [11].
+
+Lemma 1. Let $( \mathbf { x } , \tilde { \mathbf { x } } ) \in \mathcal { X } \times \mathcal { X }$ . Then for a fixed generator, $G$ , the $i ^ { t h }$ component of the optimal discriminator, $D ^ { * } \big ( ( { \bf x } , \tilde { { \bf x } } ) \big )$ is given by
+
+$$
+D ^ { * } ( ( \mathbf { x } , \tilde { \mathbf { x } } ) ) _ { i } = \frac { p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { s w a p ( \{ i \} ) } ) } { p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { s w a p ( \{ i \} ) } ) + p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) ) }
+$$
+
+for each $i \in \{ 1 , . . . , d \}$ .
+
+Proof. The proof of this involves some basic integral manipulation to get that the objective in (7) can be rewritten as
+
+$$
+\sum _ { i = 1 } ^ { d } \int _ { \chi \times \chi } \log D ( ( { \bf x } , \tilde { \bf x } ) ) _ { i } p ( ( { \bf x } , \tilde { \bf x } ) _ { \mathrm { s w a p } ( \{ i \} ) } ) + \log ( 1 - D ( ( { \bf x } , \tilde { \bf x } ) ) _ { i } ) p ( ( { \bf x } , \tilde { \bf x } ) ) \mathrm { d } { \bf x } .
+$$
+
+We then observe that $y \mapsto a \log y + b \log ( 1 - y )$ achieves its maximum in $[ 0 , 1 ]$ at $\frac { a } { a + b }$ and so the objective is maximized (with respect to $D$ , for fixed $G$ ) when
+
+$$
+D ^ { * } ( ( \mathbf { x } , \tilde { \mathbf { x } } ) ) _ { i } = \frac { p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( \{ i \} ) } ) } { p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( \{ i \} ) } ) + p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) ) }
+$$
+
+for each $i \in \{ 1 , . . . , d \}$
+
+With this lemma, we are now able to prove our key result.
+
+Theorem 3. Equation (7) is maximized (with respect to $G$ ) if and only if equation $( l )$ (in the main paper) is satisfied by $G$ .
+
+Proof. We begin by rewriting our loss, substituting in $D ^ { * }$ , to give us the following loss for $G$ :
+
+$$
+\begin{array} { r l } { \mathcal { L } _ { G } = \displaystyle \sum _ { S \subset \{ 1 , \ldots , d \} } \mathbb { E } _ { \mathbf { x } , \bar { \mathbf { x } } } \Big ( \displaystyle \sum _ { i \in S } \log \frac { p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \operatorname { s w a p } ( S \backslash i ) } \big ) } { p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \operatorname { s w a p } ( S \backslash i ) } \big ) + p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \operatorname { s w a p } ( S ) } \big ) } } & { } \\ { + \displaystyle \sum _ { i \notin S } \log \frac { p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \operatorname { s w a p } ( S ) } \big ) } { p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \operatorname { s w a p } ( S \cup i ) } \big ) + p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \operatorname { s w a p } ( S ) } \big ) } \Big ) } & { } \end{array}
+$$
+
+where we note that
+
+$$
+( ( \mathbf { x } , { \tilde { \mathbf { x } } } ) _ { \operatorname { s w a p } ( S ) } ) _ { \operatorname { s w a p } ( \{ i \} ) } = { \biggl \{ } { \bigl ( } \mathbf { x } , { \tilde { \mathbf { x } } } { \bigr ) } _ { \operatorname { s w a p } ( S \backslash i ) } { \mathrm { ~ i f ~ } } i \in S 
+$$
+
+Then by inspecting each term in the sum, we see that each term is a KL-divergence term that is minimized only when
+
+$$
+p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( \{ S \backslash i \} ) } ) = p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S ) } )
+$$
+
+and
+
+$$
+p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( \{ S \cup i \} ) } \big ) = p \big ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S ) } \big )
+$$
+
+for every $i \in \{ 1 , . . . , d \}$ , every $S \subset \{ 1 , . . . , d \}$ and each $( \mathbf { x } , \tilde { \mathbf { x } } ) \in \mathcal { X } \times \mathcal { X }$ .
+
+By iteratively applying equation (9), we get that
+
+$$
+\begin{array} { r l } & { p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S ) } ) = p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S \setminus 1 ) } ) = \ldots = p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S \setminus \{ 1 , \ldots , d - 1 \} ) } ) } \\ & { \qquad = p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) _ { \mathrm { s w a p } ( S \setminus \{ 1 , \ldots , d \} ) } ) = p ( ( \mathbf { x } , \tilde { \mathbf { x } } ) } \end{array}
+$$
+
+proving the theorem.
+
+Lemma 2. The addition of the term $\mathcal { L } _ { f }$ to our loss, does not affect the optimal solution to it.
+
+Proof. By theorem 2, it suffices to show that any distribution satisfying equation (1) also minimizes $\operatorname* { m a x } _ { f } \mathcal { L } _ { f }$ . But we note that, as shown in [2], $\operatorname* { m a x } _ { f } \mathcal { L } _ { f }$ (or rather $\operatorname* { s u p } _ { f } \mathcal { L } _ { f } )$ is the Wasserstein distance between $\mathbf { X }$ and $\tilde { \mathbf { X } }$ , which is 0 (and minimal) when ${ \bf x } \ { \overset { d . } { = } } \ { \tilde { \bf X } }$ . It therefore suffices to show that equation (1) implies ${ \bf X } \overset { d . } { = } \tilde { \bf X }$ .
+
+Let $S = \{ 1 , . . . , d \}$ . Then if $( \mathbf { X } , \tilde { \mathbf { X } } )$ satisfy equation (1), we get that $( { \bf X } , \tilde { \bf X } ) \stackrel { d . } { = } ( \tilde { \bf X } , { \bf X } )$ . Since the joint distributions are equal, it follows that the marginal distributions are equal and so by projecting onto the first $d$ variables, we get that ${ \bf x } \stackrel { d . } { = } \tilde { \bf X }$ . □
+
+# MINE
+
+We state the key theory used by MINE to estimate the mutual information. For full details see the original paper, [4].
+
+The mutual information is defined as
+
+$$
+I ( U ; V ) = \int _ { U \times \mathcal { V } } \log \frac { d \mathbb { P } _ { U V } } { d \mathbb { P } _ { U } \otimes d \mathbb { P } _ { V } } d \mathbb { P } _ { U V }
+$$
+
+where $U$ and $V$ are random variables over some spaces $\mathcal { U }$ and $\nu$ , respectively with joint measure $\mathbb { P } _ { U V }$ and marginal measures $\begin{array} { r } { \mathbb { P } _ { U } = \int _ { \mathcal { V } } d \mathbb { P } _ { U V } } \end{array}$ and $\begin{array} { r } { \bar { \mathbb { P } _ { V } } = \int _ { \mathcal { U } } d \mathbb { P } _ { U V } } \end{array}$ , respectively.
+
+The mutual information can also be characterized by the Kullback-Leibler divergence, $D _ { K L }$ , as
+
+$$
+I ( U ; V ) = D _ { K L } ( \mathbb { P } _ { U V } | | \mathbb { P } _ { U } \otimes \mathbb { P } _ { V } )
+$$
+
+The Donsker-Varadhan representation then gives us for any two probability measures $\mathbb { P }$ and $\mathbb { Q }$ over a probability space $\Omega$
+
+$$
+D _ { K L } ( \mathbb { P } | | \mathbb { Q } ) = \operatorname* { s u p } _ { T : \Omega \to \mathbb { R } } \mathbb { E } _ { \mathbb { P } } [ T ] - \log ( \mathbb { E } _ { \mathbb { Q } } [ e ^ { T } ] )
+$$
+
+where the supremum is taken over all functions $\mathrm { T }$ such that the two expectations are finite.
+
+A simple corollary of this is that fixing a class $\mathcal { F }$ of functions (such as a parametrized class $\{ T _ { \theta } : \theta \in$ $\Theta \}$ ) over which the supremum is taken will provide us with a lower bound for the mutual information that approaches the true mutual information as the class becomes sufficiently rich. MINE [4] fix the class to be parametric in this way - given a fixed neural network architecture, they let ${ \mathcal F } = \{ T _ { \theta } :$ $\theta \in \Theta \}$ be the set of all functions parametrized by this network.
+
+# IMPLEMENTATION OF KNOCKOFFGAN
+
+In the experiments, the depth of the generator, discriminator and WGAN-GP networks is set to 4 and power network is set to 3. The number of hidden nodes in each layer is $d / 4 , d / 1 6 d / 4$ for the generator, discriminator, and WGAN-GP, respectively. For the power network, we use 2 diagonal matrices for each layer to make two hidden nodes for each feature separately. We use ReLu and tanh as the activation functions for each layer except for the output layer where we use a linear activation function for the generator, power network and WGAN-GP networks and sigmoid activation function for the discriminator network. The number of samples in each mini-batch is 128. KnockoffGAN is implemented in tensorflow.
+
+# DETAILS OF BENCHMARKS
+
+We use the following links for the implementations of 3 benchmarks.
+
+• Knockoff: http://web.stanford.edu/group/candes/knockoffs/ software/knockoff/index.html   
+• BHq Max: http://web.stanford.edu/group/candes/knockoffs/ software/knockoff/tutorial-4-r.html   
+• BHq Marginal: Modifying the original code of BHq Max in http://web.stanford. edu/group/candes/knockoffs/software/knockoff/tutorial-4-r. html
+
+Except for the knockoff generation step, KnockoffGAN follows the same procedures as the original knockoff framework described at http://web.stanford.edu/group/candes/ knockoffs/software/knockoff/tutorial-2-r.html to select features.
+
+# ADDITIONAL EXPERIMENTS
+
+INDEPENDENT GAUSSIANS
+
+In the following experiment, features were taken to be i.i.d. Gaussian, with mean 0 and variance $\textstyle { \frac { 1 } { n } }$ ， i.e. $\mathbf { X } \sim { \mathcal { N } } ( 0 , { \textstyle { \frac { 1 } { n } } } \mathbf { I } _ { n } )$ . The results are reported in Fig. 5.
+
+![](images/7ed8301505d420d89461cf749ea026c9cf4e0fea1d784de003349b407a5271a8.jpg)  
+Figure 5: Comparison of KnockoffGAN with the benchmarks for $\mathbf { X } \sim { \mathcal { N } } ( 0 , { \textstyle { \frac { 1 } { n } } } \mathbf { I } _ { n } )$ . TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 \dot { 0 } \% )$ .
+
+As we see in Fig. 5, all methods control the FDR at or very close to the specified $10 \%$ threshold. We also see that across the entire range of $\alpha$ , KnockoffGAN achieves a very similar TPR to the original knockoff framework.
+
+# NON-GAUSSIAN SETTINGS
+
+INDEPENDENT UNIFORM
+
+In this experiment we set the feature distribution to be a Uniform distribution with mean 0 and variance $\frac { \mathbf { i } } { n }$ (to be consistent with the Gaussian experiments). Fig. 6 displays the results for each component of $\mathbf { X }$ being i.i.d. $\mathcal { U } ( - \sqrt { 3 / n } , \sqrt { 3 / n } )$ . Once again we see that KnockoffGAN consistently outperforms the original knockoff framework, achieving a higher TPR across the entire range of $\alpha$ in both settings.
+
+![](images/4d7fcb7cbd985e221247bde514c592cf50b37603fe5c00718530558cc4079fa7.jpg)  
+Figure 6: Comparison of KnockoffGAN with the benchmarks for $\mathbf { X } \sim { \mathcal { U } } ( - { \sqrt { 3 / n } } , { \sqrt { 3 / n } } )$ . TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+# DIRICHLET
+
+In this experiment we set the feature distribution to be a Dirichlet $( 1 , . . . , 1 )$ distribution - i.e. the uniform distribution over the $( d - 1 )$ -simplex. Correlation here exists through the requirement that $\textstyle \sum _ { i = 1 } ^ { d } X _ { i } = 1$ .
+
+![](images/6cc23a1f2f5605c119493e8659c4131de7f5fe9922b9a544088b3deaeafbbbe4.jpg)  
+Figure 7: Comparison of KnockoffGAN with the benchmarks for $\mathbf { X } \sim$ Dirichlet $( 1 , . . . , 1 )$ . TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+# GAUSSIAN MIXTURE MODELS
+
+For the GMM2 model we set the means $( \mathbf { m } ^ { 1 } , \mathbf { m } ^ { 2 } )$ of the 2 Gaussians to be:
+
+• $m _ { i } ^ { 1 } = 1$ for $i = 1$ to 100 and 0 for $i = 1 0 1$ to 1000, • $m _ { i } ^ { 2 } = - 1$ for $i = 1$ to 100 and 0 for $i = 1 0 1$ to 1000.
+
+![](images/a0f17338b0f677cb726a7a2629da3ffe9eec7aa0e07d281911e6d4903966c658.jpg)  
+Figure 8: Comparison of KnockoffGAN with the benchmarks for $\mathbf { X } \ \sim \ \mathbf { G M M } 2$ . TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+For the GMM3 model we set the means $( \mathbf { m } ^ { 1 } , \mathbf { m } ^ { 2 } , \mathbf { m } ^ { 3 } )$ of the 3 Gaussians to be:
+
+• $m _ { i } ^ { 1 } = 1$ for $i = 1$ to 100 and 0 for $i = 1 0 1$ to 1000,   
+• $m _ { i } ^ { 2 } = 1$ for $i = 1$ to 50 and $^ { - 1 }$ for $i = 5 1$ to 100 and 0 for $i = 1 0 1$ to 1000, • $m _ { i } ^ { 3 } = - 1$ for $i = 1$ to 100 and 0 for $i = 1 0 1$ to 1000.
+
+![](images/020fa041c0834017f1811ff25c2ed721cd0695ddc9b62053ef67c8ff8eff3c15.jpg)  
+Figure 9: Comparison of KnockoffGAN with the benchmarks for $\mathbf { X } \sim \mathbf { G M M } 3$ . TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 1 0 \% )$ .
+
+# HYPER-PARAMETER ANALYSIS
+
+Hyper-parameter selection in the feature selection problem is difficult; hyper-parameter selection cannot be performed using cross-validation as we do not have access to ground truth. The hyperparameters must therefore be fixed a priori. For this we believe that $\lambda = 1$ and $\mu = 1$ are perhaps the most canonical choice we could make and thus these were used in the main manuscript. In the following experiments, we investigate the sensitivity of the results to various settings of $\lambda$ and $\mu$ . The results below are in the auto-regressive Uniform setting with Y-Logit and FDR set to $10 \%$ .
+
+Table 2: Evaluation of the hyper-parameter $\lambda$ in the auto-regressive uniform setting with Y-Logit and FDR threshold $10 \%$   
+
+<table><tr><td rowspan=2 colspan=8>TPR                         入0    0.1  0.5   1     5   10</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>?</td><td rowspan=1 colspan=1>0.10.20.40.8</td><td rowspan=1 colspan=1>70.368.742.422.4</td><td rowspan=1 colspan=1>76.272.655.127.4</td><td rowspan=1 colspan=1>75.771.951.125.3</td><td rowspan=1 colspan=1>77.072.753.127.7</td><td rowspan=1 colspan=1>75.172.953.827.5</td><td rowspan=1 colspan=1>76.073.753.227.6</td></tr></table>
+
+Table 3: Evaluation of the hyper-parameter $\mu$ in the auto-regressive uniform setting with Y-Logit and FDR threshold $10 \%$   
+
+<table><tr><td rowspan=2 colspan=8>TPR                          从0    0.1  0.5    1     5    10</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>5</td><td rowspan=1 colspan=1>10</td></tr><tr><td rowspan=1 colspan=1>?</td><td rowspan=1 colspan=1>0.10.20.40.8</td><td rowspan=1 colspan=1>70.368.742.422.4</td><td rowspan=1 colspan=1>76.272.655.127.4</td><td rowspan=1 colspan=1>75.771.951.125.3</td><td rowspan=1 colspan=1>77.072.753.127.7</td><td rowspan=1 colspan=1>75.172.953.827.5</td><td rowspan=1 colspan=1>76.073.753.227.6</td></tr></table>
+
+As can be seen in Table 2 and 3, the performance of KnockoffGAN is not sensitive to the value of $\lambda$ and $\mu$ . The only significant difference can be seen when either $\lambda$ or $\mu$ is set to 0 which represents the exclusion of either the power network or WGAN-discriminator network, respectively, from the model. In particular, the lack of sensitivity to $\mu$ aligns with Lemma 2 in which we see that there is not a trade-off between $\mathcal { L } _ { f }$ and $\mathcal { L } _ { D }$ but rather the two can be simultaneously minimised.
+
+To further understand the effects of the WGAN network, we report the final values of the other losses ( $\mathcal { L } _ { D }$ and $\mathcal { L } _ { P }$ ) when $\mu = 1$ and $\mu = 0$ (i.e. with and without the WGAN regularisation). The results are given below in the auto-regressive Uniform setting with Y-Logit and FDR set to $10 \%$ .
+
+<table><tr><td rowspan=2 colspan=6>Loss          LD                Lpμ=0|μ=11|μ=0|μ=1</td></tr><tr><td rowspan=1 colspan=1>μ=0</td><td rowspan=1 colspan=1>μ=1</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.1</td><td rowspan=1 colspan=1>0.6894</td><td rowspan=1 colspan=1>0.6962</td><td rowspan=1 colspan=1>0.0014</td><td rowspan=1 colspan=1>0.0203</td></tr><tr><td rowspan=2 colspan=1>?</td><td rowspan=2 colspan=1>0.20.4</td><td rowspan=1 colspan=1>0.7005</td><td rowspan=1 colspan=1>0.6964</td><td rowspan=1 colspan=1>0.0018</td><td rowspan=1 colspan=1>0.0115</td></tr><tr><td rowspan=1 colspan=1>0.6919</td><td rowspan=1 colspan=1>0.6955</td><td rowspan=1 colspan=1>0.0046</td><td rowspan=1 colspan=1>0.0180</td></tr><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>0.7013</td><td rowspan=1 colspan=1>0.6960</td><td rowspan=1 colspan=1>0.0068</td><td rowspan=1 colspan=1>0.0311</td></tr></table>
+
+Table 4: Final values of the other training losses when $\mu = 0$ or $\mu = 1$ in the auto-regressive uniform setting with Y-Logit and FDR threshold $10 \%$
+
+As can be seen in Table 4, the inclusion of the WGAN network improves the final value of $\mathcal { L } _ { D }$ , bringing it significantly closer to its optimal value of $\log ( 2 ) \approx 0 . 6 9 3$ . On the other hand, the power network loss is increased, however, this trade-off is expected and acceptable - the FDR guarantees rely on the discriminator loss $( \mathcal { L } _ { D } )$ and not the power network. As we see in Table 3, the TPR does not suffer from this increased loss for the power network.
+
+For our final hyper-parameter evaluation, we investigate the effect of varying the hinting probability, $p$ , which determines the probability with which $B _ { i } = 1$ . We note that this hyper-parameter is used to trade-off between speed of learning and optimality of the learned solution. A low probability makes for fast convergence, but suboptimal convergence whereas a high probability makes for slow convergence (but a more optimal solution). We chose 0.9 to balance this, following the implementation of [38]. To demonstrate this trade-off we vary this hyper-parameter (from 0 to 0.9). The results below are for the auto-regressive Uniform distribution with Y-Logit and FDR set to $10 \%$ .
+
+<table><tr><td rowspan=2 colspan=2>TPR</td><td rowspan=1 colspan=6>TPR                         p</td></tr><tr><td rowspan=1 colspan=1>0</td><td rowspan=1 colspan=1>0.2</td><td rowspan=1 colspan=1>0.4</td><td rowspan=1 colspan=1>0.6</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>0.9</td></tr><tr><td rowspan=1 colspan=1>?</td><td rowspan=1 colspan=1>0.10.20.40.8</td><td rowspan=1 colspan=1>73.367.751.218.0</td><td rowspan=1 colspan=1>74.768.451.620.4</td><td rowspan=1 colspan=1>75.069.151.721.4</td><td rowspan=1 colspan=1>75.369.751.922.4</td><td rowspan=1 colspan=1>75.772.452.925.4</td><td rowspan=1 colspan=1>77.072.753.127.7</td></tr></table>
+
+# RESULTS WITH FDR THRESHOLD $5 \%$
+
+In all of the synthetic experiments above, the FDR threshold is set to $10 \%$ (which is the level most thoroughly investigated by [3]). In this final experiment, we set the FDR threshold to $5 \%$ (which aligns with our real-world experiment) and verify that KnockoffGAN is capable of controlling the FDR at this level and still outperforms the original knockoff framework. We conduct the experiments on (1) an auto-regressive distribution with Gaussian marginal distributions, (2) an auto-regressive distribution with Uniform marginal distributions, and (3) a 4-mixture Gaussian mixture model.
+
+![](images/fcdf84a9420cf27f104cb88c984915c8a75c6aae05ee54a8e0adae6ac7f18d44.jpg)  
+Table 5: Evaluation of the hinting probability, $p$ , in the auto-regressive uniform setting with Y-Logit and FDR threshold $10 \%$   
+Figure 10: A comparison of the performance of KnockoffGAN for $\mathbf { X }$ distributed as an auto-regressive distribution with Gaussian marginal distributions. TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 5 \% )$ .
+
+![](images/03d03bc84b6b753f2fa1dc871a278d2a0694ca55503c706dff507b707fcf8b07.jpg)  
+Figure 11: A comparison of the performance of KnockoffGAN for $\mathbf { X }$ distributed as an auto-regressive distribution with Uniform marginal distributions. TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 5 \% )$ .
+
+![](images/c2b8cdba9118938807c0a611fa489c4f3e5832ebbf6953953b5bf237192422a5.jpg)  
+Figure 12: A comparison of the performance of KnockoffGAN for X distributed as 4-mixture Gaussian mixture model. TPR is used to quantify performance and FDR is reported to verify that it is at the specified threshold $( 5 \% )$ .
+
+# STATISTICS OF REAL-WORLD BIOBANK DATASET
+
+To preserve anonymity of the authors, the full details of this dataset will be given upon acceptance of the paper. In Table 1, we provide the basic statistics of the real-world biobank dataset.
+
+<table><tr><td rowspan=1 colspan=1> Staticstics</td><td rowspan=1 colspan=1>Values</td></tr><tr><td rowspan=1 colspan=1>No of patients</td><td rowspan=1 colspan=1>86082</td></tr><tr><td rowspan=1 colspan=1>No of features</td><td rowspan=1 colspan=1>387</td></tr><tr><td rowspan=1 colspan=1>Pearson correlation across the features</td><td rowspan=1 colspan=1>25%: 0.0042, 50%: 0.0120,75%: 0.0332</td></tr><tr><td rowspan=1 colspan=1>Pearson correlation with the outcome</td><td rowspan=1 colspan=1>CVD: 25%: 0.0033, 50%: 0.0091,75%: 0.0199Diabetes: 25%: 0.0068, 50%: 0.0179,75%: 0.0439</td></tr><tr><td rowspan=1 colspan=1>Label distribution</td><td rowspan=1 colspan=1>CVD: 1252 patients (1.5%)Diabetes: 3932 patients (4.6%)</td></tr></table>
+
+Table 6: Basic statistics of real-world biobank dataset $\%$ means percentile in Pearson correlation rows)

parse/train/BygWRaVYwH/BygWRaVYwH.md

@@ -0,0 +1,352 @@
+# GENERALIZED INNER LOOP META-LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Many (but not all) approaches self-qualifying as “meta-learning” in deep learning and reinforcement learning fit a common pattern of approximating the solution to a nested optimization problem. In this paper, we give a formalization of this shared pattern, which we call GIMLI, prove its general requirements, and derive a general-purpose algorithm for implementing similar approaches. Based on this analysis and algorithm, we describe a library of our design, unnamedlib, which we share with the community to assist and enable future research into these kinds of meta-learning approaches. We end the paper by showcasing the practical applications of this framework and library through illustrative experiments and ablation studies which they facilitate.
+
+# 1 INTRODUCTION
+
+Although it is by no means a new subfield of machine learning research (see e.g. Schmidhuber, 1987; Bengio, 2000; Hochreiter et al., 2001), there has recently been a surge of interest in metalearning (e.g. Maclaurin et al., 2015; Andrychowicz et al., 2016; Finn et al., 2017). This is due to the methods meta-learning provides, amongst other things, for producing models that perform well beyond the confines of a single task, outside the constraints of a static dataset, or simply with greater data efficiency or sample complexity. Due to the wealth of options in what could be considered “meta-” to a learning problem, the term itself may have been used with some degree of underspecification. However, it turns out that many meta-learning approaches, in particular in the recent literature, follow the pattern of optimizing the “meta-parameters” of the training process by nesting one or more inner loops in an outer training loop. Such nesting enables training a model for several steps, evaluating it, calculating or approximating the gradients of that evaluation with respect to the meta-parameters, and subsequently updating these meta-parameters.
+
+This paper makes three contributions. First, we propose a formalization of this general process, which we call Generalized Inner Loop Meta-Learning (GIMLI), and show that it subsumes several recent approaches. The proposed formalism allows us to describe the meta-optimization process in general terms and analyse its requirements. Second, we derive a general algorithm that supports the implementation of various kinds of meta-learning fitting within the GIMLI framework and its requirements. Third, based on this analysis and algorithm, we describe a lightweight PyTorch library that enables the straightforward implementation of any meta-learning approach that fits within the GIMLI framework in canonical PyTorch, such that existing codebases require minimal changes, supporting third party module implementations and a variety of optimizers. Through a set of indicative experiments, we showcase the sort of research directions that are facilitated by our formalization and the corresponding library.
+
+The overarching aim of this paper is not—emphatically—to purport some notion of ownership or precedence in any sense over existing efforts by virtue of having proposed a unifying formulation. Rather, in pointing out similarities under such unification, it provides theoretical and practical tools for facilitating further research in this exciting domain.
+
+# 2 GENERALIZED INNER LOOP META-LEARNING
+
+Whereby “meta-learning” is taken to mean the process of “learning to learn”, we can describe it as a nested optimization problem according to which an outer loop optimizes meta-variables controlling the optimization of model parameters within an inner loop. The aim of the outer loop should be to improve the meta-variables such that the inner loop produces models which are more suitable according to some criterion. In this section, we will formalize this process, which we call Generalized Inner Loop Meta-Learning (GIMLI). We will define our terms in Section 2.1, give a formal description of the inner and outer loop’s respective optimization problems in Section 2.2 and 2.3, followed by a description and proof of the requirements under which the process can be run in Section 2.4. Finally, in Section 2.5 we describe an algorithm which permits an efficient and exact implementation of GIMLI, agnostic to the model and optimizers used.
+
+# 2.1 DEFINITIONS
+
+Let us assume we wish to train a model parameterized by $\theta$ . Let $\varphi$ describe some collection of possibly unrelated “meta-parameters” describing some aspect of the process by which we train our model. These could be, for example the learning rate or some other real-valued hyperparameters, task loss weights in multi-task learning, or perhaps the initialization of the model weights at the beginning of training. For disambiguation, we will refer to the subset of $\varphi$ describing optimization parameters by $\varphi ^ { o p t }$ , and those meta-parameters which parameterize aspects of the training loss calculation at every step (e.g. the loss itself, the task mixture, regularization terms, etc) by $\varphi ^ { l o \overline { { s } } s }$ , i.e. $\varphi = \varphi ^ { o p t } \cup \varphi ^ { l o s s }$ . We will give several concrete examples in Section 3.
+
+Let $\mathcal { L } ^ { t r a i n }$ be a function of $\theta$ and $\varphi$ corresponding to the overall training objective we seek to minimize directly or indirectly (e.g. via an upper bound, a Monte Carlo estimate of an expectation, etc). Other elements of the objective such as the dataset, and hyperparameters or other aspects of training not covered by $\varphi$ , are assumed to be implicit and held fixed in $\mathcal { L } ^ { t r a i n }$ for notational simplicity. With this, the process by which we train a model to obtain test-time parameters $\theta ^ { * }$ can be formalized as shown in Equation $1 ^ { 1 }$ .
+
+$$
+\theta ^ { * } = \operatorname * { a r g m i n } ( \theta ; \mathcal { L } ^ { t r a i n } ( \theta , \varphi ) )
+$$
+
+We assume that this search will be performed using an iterative gradient-based method such as some form of gradient descent as formalized in Section 2.2, and thus that the derivative $\nabla _ { \boldsymbol { \theta } } \mathcal { L } ^ { t r a i n } ( \boldsymbol { \theta } , \boldsymbol { \varphi } )$ exists, as an obvious requirement.
+
+Furthermore, let $\mathcal { L } ^ { v a l }$ be a function exclusively of $\theta$ (except the specific case where $\varphi$ describes some aspect of the model, e.g. initialization, as is done in MAML (Finn et al., 2017)) describing some objective we wish to measure the post-training performance of the model against. This could be a validation set from the same task the model was trained on, from a collection of other tasks, or some other measure of the quality of the model parameterized by $\theta ^ { * }$ . Typically, the aforementioned iterative process is not run to convergence, but rather to the point where an intermediate set of model parameters is considered satisfactory according to some criterion (e.g. best model under $\mathcal { L } ^ { v a l }$ for a fixed budget of training steps, or after no improvement is seen for a certain number of training steps, etc.), and these intermediate parameters will serve as $\theta ^ { * }$ .
+
+# 2.2 TRAINING
+
+The process by which we typically approximate $\theta ^ { * }$ against $\mathcal { L } ^ { t r a i n }$ decomposes into a sequence of updates of $\theta$ . At timestep $t$ , we compute $\theta _ { t + 1 }$ from $\theta _ { t }$ by first computing a step-specific loss $\ell _ { t } ^ { t r a i n } ( \theta _ { t } , \varphi ^ { l o s s } )$ . Note that this loss may itself also be a function of step-specific factors, such as the training data used for that timestep, which we leave implicit here for notational simplicity. Following this, we typically compute or approximate (e.g. as in reinforcement learning) the gradients $\nabla _ { \theta _ { t } } \mathcal { \bar { \ell } } _ { t } ^ { t r a i n } ( \theta _ { t } , \varphi ^ { \bar { l } \ o s s } )$ of this loss with regard to $\theta _ { t }$ , by using algorithms such as backpropagation (Rumelhart et al., 1985). We then typically use an optimizer to “apply” these gradients to the parameters $\theta _ { t }$ to obtain updated parameters $\theta _ { t + 1 }$ . As such, optimization processes such as e.g. Adagrad (Duchi et al., 2011) may be stateful, in that they exploit gradient history to produce adaptive “local” learning rates. Because some aspects of the optimization process may be covered by our choice of $\varphi$ , we denote this optimization step at time-step $t$ by $\mathbf { o p t } _ { t }$ as shown in Equation 2, where timestep-specific attributes of the optimizer are left implicit by our use of the step subscript.
+
+$$
+\theta _ { t + 1 } =  { \mathbf { o p t } } _ { t } ( \theta _ { t } , \varphi ^ { o p t } , G _ { t } ) \quad \mathrm { w h e r e } \quad G _ { t } = \nabla _ { \theta _ { t } } \ell _ { t } ^ { t r a i n } ( \theta _ { t } , \varphi ^ { l o s s } )
+$$
+
+For example, where we might use SGD as an optimizer, with the learning-rate being a meta-variable $\varphi ^ { o p t }$ , we could instantiate equation 2 as follows:
+
+$$
+\begin{array} { r } { \mathbf { o p t } _ { t } ( \theta _ { t } , \varphi ^ { o p t } , G _ { t } ) : = \theta _ { t } - \varphi ^ { o p t } \cdot G _ { t } \quad \mathrm { w h e r e } \quad G _ { t } = \nabla _ { \theta _ { t } } \ell _ { t } ^ { t r a i n } \big ( \theta _ { t } , \varphi ^ { l o s s } \big ) } \end{array}
+$$
+
+The estimation of $\theta ^ { * }$ from Equation 1 using $T + 1$ training updates according to Equation 2 yields a double recurrence in both $\theta _ { t }$ and $G _ { t }$ (as it is a function of $\theta _ { t }$ , as outlined in Equation 3).
+
+$$
+\begin{array} { r l } & { \theta ^ { * } \approx \mathbf { o p t } _ { T } ( \theta _ { T } , \varphi ^ { o p t } , G _ { T } ) = \mathbf { o p t } _ { T } ( P _ { T } , \varphi ^ { o p t } , \nabla _ { \theta _ { T } } \ell _ { T } ^ { t r a i n } ( P _ { T } , \varphi ^ { l o s s } ) ) } \\ & { P _ { T } = \mathbf { o p t } _ { T - 1 } ( \theta _ { T - 1 } , \varphi ^ { o p t } , G _ { T - 1 } ) = \mathbf { o p t } _ { T - 1 } ( P _ { T - 1 } , \varphi ^ { o p t } , \nabla _ { \theta _ { T - 1 } } \ell _ { T - 1 } ^ { t r a i n } ( P _ { T - 1 } , \varphi ^ { l o s s } ) ) } \end{array}
+$$
+
+$$
+P _ { 1 } = \mathbf { o p t } _ { 0 } ( \theta _ { 0 } , \varphi ^ { o p t } , G _ { 0 } ) = \mathbf { o p t } _ { 0 } ( \theta _ { 0 } , \varphi ^ { o p t } , \nabla _ { \theta _ { 0 } } \ell _ { 0 } ^ { t r a i n } ( \theta _ { 0 } , \varphi ^ { l o s s } ) )
+$$
+
+From this we see that the optimization process used to train a variety of model types, with a variety of optimization methods, can be described as a function yielding test-time model parameters $\theta ^ { * }$ potentially as a function of parameter history $\theta _ { 1 } , \ldots , \theta _ { T }$ and of meta-parameters $\varphi$ (if any exist). While this may seem like a fairly trivial formalization of a ubiquitous training process, we will see in Section 2.4 that if a few key requirements are met, this process can be nested as the inner loop within an outer loop containing—amongst other things—a meta-training process. From this process, described in Section 2.3, we estimate values of $\varphi$ which improve our training process against some external metric.
+
+# 2.3 META-TRAINING
+
+We now describe the outer loop optimization problem which wraps around the inner loop described in Section 2.2. Through this process, we seek a value $\varphi ^ { * }$ which ensures that the training process $\mathcal { L } ^ { t r a i n } ( \theta , \varphi ^ { * } )$ produces parameters $\theta ^ { * }$ which perform best against some metric $\mathcal { L } ^ { v a l } ( \theta ^ { * } )$ which we care about. The formalization and decomposition of this “meta-training process” into nested optimization problems is shown in Equation 4.
+
+$$
+\begin{array} { r l } & { \boldsymbol { \varphi } ^ { * } = \operatorname * { a r g m i n } \left( \boldsymbol { \varphi } ; \mathcal { L } ^ { v a l } ( \boldsymbol { \theta } ^ { * } ) \right) } \\ & { \quad = \operatorname * { a r g m i n } \left( \boldsymbol { \varphi } ; \mathcal { L } ^ { v a l } \left( \operatorname * { a r g m i n } \left( \boldsymbol { \theta } ; \mathcal { L } ^ { t r a i n } \left( \boldsymbol { \theta } , \boldsymbol { \varphi } \right) \right) \right) \right) } \end{array}
+$$
+
+In this section, we introduce a formalization of an iterative process allowing us to approximate this nested optimization process. Furthermore, we describe a general iterative algorithm by which the process in Equation 4 can be approximated by gradient-based methods while jointly estimating $\theta ^ { * }$ according to the process in Equation 1.
+
+An iterative process by which we can estimate $\varphi ^ { * }$ given Equation 4 following the sort of decomposition of the training process described Equation 1 into the training process described in Equations $2 -$ 3 is described below. Essentially, an estimate of $\theta ^ { * }$ is obtained following $T + 1$ steps training as outlined in Equation 3, which is then evaluated against $\mathcal { L } ^ { v a l }$ . The gradient of this evaluation, $\nabla _ { \varphi } \mathcal { L } ^ { v a l } ( \theta ^ { * } )$ is then obtained through backpropagation, and used to update $\varphi$ . Using $\tau$ as time-step counter to symbolize the time-scale being different from that used in the “inner loop”, we formalize this update in Equation 5 where metaopt $\tau$ denotes the optimization process used to update $\varphi _ { \tau }$ using $M _ { \tau }$ at that time-step.
+
+$$
+\begin{array} { r l } & { \varphi _ { \tau + 1 } = \mathbf { m e t a o p t } _ { \tau } ( \varphi _ { \tau } , M _ { \tau } ) \quad \mathrm { w h e r e } \quad M _ { \tau } = \nabla _ { \varphi _ { \tau } } \mathcal { L } ^ { v a l } ( \theta ^ { * } ) } \\ & { \qquad = \mathbf { m e t a o p t } _ { \tau } ( \varphi _ { \tau } , \nabla _ { \varphi _ { \tau } } \mathcal { L } ^ { v a l } ( \mathbf { o p t } _ { T } ( P _ { T } , \varphi ^ { o p t } , G _ { T } ) ) ) } \\ & { \mathrm { r e } P _ { T } = \mathbf { o p t } _ { T - 1 } ( P _ { T - 1 } , \varphi ^ { o p t } , \nabla _ { \theta _ { T - 1 } } \ell _ { T - 1 } ^ { t r a i n } ( P _ { T - 1 } , \varphi ^ { l o s s } ) ) } \\ & { \qquad \vdots } \end{array}
+$$
+
+# 2.4 KEY REQUIREMENTS
+
+For gradient-based meta-learning as formalized in Section 2.3—in particular through the process formalized in Equation 5—to be possible, a few key requirements must be met. We enumerate them here, and then discuss the conditions under which they are met, either analytically or through choice of model, loss function, or optimizer.
+
+I. $\mathcal { L } ^ { v a l }$ is a differentiable function of its input, i.e. the derivative $\nabla _ { \theta ^ { * } } \mathcal { L } ^ { v a l } ( \theta ^ { * } )$ exists.
+
+II. The optimization process opt in Equation 2 is a differentiable2 function of $\theta$ and $G ^ { 3 }$
+
+III. Either or both of the following conditions hold:
+
+(a) there exist continuous optimization hyperparameters (e.g. a learning rate $\alpha$ ) covered by $\varphi ^ { o p t }$ (e.g. $\alpha \subseteq \varphi ^ { o p t } ,$ ) and opt in Equation 2 is a differentiable function of $\varphi ^ { o p t }$ , or   
+(b) the gradient $G _ { t }$ for one or more time-steps in Equations 1–3 is a function of $\varphi ^ { l o s s }$ (i.e. the derivative $\nabla _ { \varphi ^ { l o s s } } \ell ^ { t r a i n } ( \theta , \varphi ^ { l o s s } )$ exists).
+
+In the remainder of this section, we show that based on the assumptions outlined in Section 2.1, namely the existence of gradients on the validation objective $\mathcal { L } ^ { v a l }$ with regard to model parameters $\theta$ and of gradients on the training objective $\mathcal { L } ^ { t r a i n }$ with regard to both model parameters $\theta$ and metaparameters $\varphi$ , there exist gradients on the validation objective $\mathcal { L } ^ { v a l }$ with regard to $\varphi$ . We will then, in the next section, demonstrate how to implement this process by specifying an update algorithm for meta-variables.
+
+Implementing an iterative process as described in Equation 5 will exploit the chain rule for partial derivatives in order to run backpropagation. The structure of the recurrence means we need to ensure that $\nabla _ { \theta _ { t } } \mathcal { L } ^ { v a l } ( \theta ^ { * } )$ exists for $t \in \{ 0 , \ldots , T \}$ in order to compute, for all such $\theta _ { t }$ , gradient paths $( \nabla _ { \theta _ { t } } \mathcal { L } ^ { v \bar { a } l } ( \theta ^ { * } ) ) \cdot ( \nabla _ { \varphi } \theta _ { t } )$ . We can prove this exists in virtue of the chain rule for partial derivatives and the requirements above:
+
+1. By the chain rule, $\nabla _ { \theta _ { t } } \mathcal { L } ^ { v a l } ( \theta _ { * } ) = \left( \nabla _ { \theta ^ { * } } \mathcal { L } ^ { v a l } ( \theta _ { * } ) \right) \cdot \left( \nabla _ { \theta _ { t } } \theta ^ { * } \right)$ exists if $\nabla _ { \theta ^ { * } } \mathcal { L } ^ { v a l } ( \theta _ { * } )$ exists (and it does, by Requirement I) and $\nabla _ { \theta _ { t } } \theta ^ { * } = \nabla _ { \theta _ { t } } \theta _ { T + 1 }$ exists. 2. Idem, $\nabla _ { \theta _ { t } } \theta _ { T + 1 } = ( \nabla _ { \theta _ { t + 1 } } \theta _ { T + 1 } ) \cdot \left( \nabla _ { \theta _ { t } } \theta _ { t + 1 } \right)$ exists by recursion over $t$ if for all $i \in [ 1 , T ]$ , $\nabla _ { { \boldsymbol { \theta } } _ { i } } \theta _ { i + 1 }$ exists, which is precisely what Requirement $\mathrm { I I }$ guarantees.
+
+Therefore $\nabla _ { \theta _ { t } } \mathcal { L } ^ { v a l } ( \theta ^ { * } )$ exists for $t \in \{ 0 , \ldots , T \}$ , leaving us to demonstrate that $\nabla _ { \varphi } \theta _ { t }$ is defined for all relevant values of $t$ as a consequence of requirements I–III. We separately consider the case of $\varphi ^ { l o s s }$ and $\varphi ^ { o p t }$ as defined in Section 2.1:
+
+1. For $\nabla _ { \varphi ^ { o p t } } \theta _ { t }$ , the gradients trivially exist as a consequence of Requirement IIIa. 2. For $\nabla _ { \varphi ^ { l o s s } } \theta _ { t }$ , by the chain rule, $\nabla _ { \varphi ^ { l o s s } } \theta _ { t } ~ = ~ \left( \nabla _ { G _ { t - 1 } } \theta _ { t } \right) \cdot \left( \nabla _ { \varphi ^ { l o s s } } G _ { t - 1 } \right)$ . From Requirement $\mathrm { I I }$ , it follows that $\nabla _ { G _ { t - 1 } } \theta _ { t }$ exists, and from Requirement IIIb, it follows that $\nabla _ { \varphi ^ { l o s s } } G _ { t - 1 }$ exists, therefore so does $\nabla _ { \varphi ^ { l o s s } } \theta _ { t }$ .
+
+Putting these both together, and having covered the union of $\varphi ^ { o p t }$ and $\varphi ^ { l o s s }$ by exhaustion, we have shown that the gradients $\nabla _ { \varphi } \mathcal { L } ^ { v a l } ( \mathbf { \bar { \theta } } ^ { * } )$ can be obtained by composition over the gradient paths $( \nabla _ { \theta _ { t } } \mathcal { L } ^ { v a l } ( \theta ^ { * } ) ) ( \nabla _ { \varphi } \theta _ { t } )$ for all $t \in [ 1 , T ]$ . In Section 2.5 we show how to implement the exact and efficient calculation of $\nabla _ { \varphi } \mathcal { L } ^ { v a l } ( \theta ^ { * } )$ . To complete this section, we indicate the conditions under which requirements I–III hold in practice.
+
+Requirement I is simply a function of the choice of evaluation metric used to evaluate the model after training as part of $\dot { \mathcal { L } } ^ { v a l }$ . If this is not a differentiable function of $\theta ^ { * }$ , e.g. BLEU (Papineni et al., 2002) in machine translation, then a proxy metric can be selected for meta-training (e.g. negative log-likelihood of held out data), or gradient estimation methods such as REINFORCE (Williams, 1992) can be used.
+
+Requirement II is a function of the choice of optimizer, but is satisfied for most popular optimizers. We directly prove that this requirement holds for SGD (Robbins & Monro, 1951) and for ADAGRAD (Duchi et al., 2011) in Appendix A, and prove it by construction for a wider class of common optimizers in the implementation and tests of the software library described in Section 4.
+
+Requirement IIIa is a function of the choice of hyperparameters and optimizer, but is satisfied for at least the learning rate in most popular optimizers. Requirement IIIb is a function of the choice of loss function $\ell ^ { t r a i n }$ (or class thereof), in that $\nabla _ { \theta _ { t } } \ell _ { t } ^ { t r a i n } ( \bar { \theta _ { t } } , \varphi ^ { l o s s } )$ needs to exist and be a differentiable function of $\varphi$ . Usually, this requirement is held where $\varphi$ is a multiplicative modifier of $\theta _ { t }$ . For algorithms such as Model Agnostic Meta-Learning (Finn et al., 2017, MAML), this requirement is equivalent to saying that the Hessian of the loss function with regard to the parameters exists.
+
+# 2.5 THE GIMLI UPDATE ALGORITHM
+
+In Algorithm 1, we present the algorithm which permits the computation of updates to metavariables through the nested iterative optimization process laid out above. To clearly disentangle different gradient paths, we employ the mathematical fiction that is the “stop-gradient” operator, which is defined as an operator which maintains the truth of the following expression:
+
+$$
+\begin{array} { r l r } { \underline { { [ - ] } } } & { : } & { \forall f \left[ \left( \underline { { [ f ( x ) ] } } = f ( x ) \right) \wedge \left( \nabla _ { x } \underline { { [ f ( x ) ] } } = 0 \right) \right] } \\ { \mathbf { s t o p } ( x ) } & { } & \end{array}
+$$
+
+As will be shown below, this will allow us to decompose the computation of updates to the metavariables through an arbitrarily complex training process, agnostic to the models and optimizers used (subject to the requirements of Section 2.4 being satisfied), into a series of local updates passing gradient with regard to the loss back through the inner loop steps. This is akin to backpropagation through time (BPTT; Rumelhart et al., 1985), a method which has been adapted to other nested optimization processes with various constraints or restrictions (Andrychowicz et al., 2016; Franceschi et al., 2017; 2018).
+
+# Algorithm 1 The GIMLI update loop
+
+Require: Current model parameters $\theta _ { t }$ , meta-parameters $\varphi _ { \tau }$   
+Require: Number of meta-parameter updates $I$ , length of unrolled inner loop $J$   
+1: for $i = 0$ to $I - 1$ do   
+2: Segment meta-parameters $\varphi _ { i } ^ { o p t } , \varphi _ { i } ^ { l o s s } \gets \mathbf { s p l i t } ( \varphi _ { \tau + i } )$   
+3: Copy model state ${ \theta } _ { 0 } ^ { \prime } \gets { \theta } _ { t }$ , optimizer state $\mathbf { o p t } _ { 0 } ^ { \prime }  \mathbf { o p t } _ { t }$   
+4: 5: for $j = 0$ te in $J - 1$ gradodel and retain gradient graph state   
+$G _ { j } \gets \nabla _ { \theta _ { j } ^ { \prime } } \ell _ { t + j } ^ { t r a i n } ( \theta _ { j } ^ { \prime } , \varphi _ { i } ^ { l o s s } )$   
+$\theta _ { j + 1 } ^ { \prime }  \mathbf { o p t } _ { j } ^ { \prime } ( \theta _ { j } ^ { \prime } , \varphi _ { i } ^ { o p t } , G _ { j } )$   
+7: end for   
+8: Initialize accumulators: $A _ { i } ^ { o p t } \gets \mathbf { z e r o s L i k e } ( \varphi _ { i } ^ { o p t } ) ; A _ { i } ^ { l o s s } \gets \mathbf { z e r o s L i k e } ( \varphi _ { i } ^ { l o s s } )$   
+9: Compute $B _ { J }  \nabla _ { \theta _ { J } ^ { \prime } } \mathcal { L } ^ { v a l } ( \theta _ { J } ^ { \prime } )$   
+10: for $j ^ { \prime } = J - 1$ to 0 do   
+11: Compute optimizer-gradient derivative $O _ { j ^ { \prime } } \gets \nabla _ { G _ { j ^ { \prime } } } \mathbf { o p t } _ { j ^ { \prime } } ^ { \prime } ( \theta _ { j ^ { \prime } } ^ { \prime } , \varphi _ { i } ^ { o p t } , G _ { j ^ { \prime } } )$   
+12: $\begin{array} { r l } & { \mathrm { U p d a t e \ } A _ { i } ^ { o p t } \gets A _ { i } ^ { o p t } + B _ { j ^ { \prime } + 1 } \cdot ( \nabla _ { \varphi _ { i } ^ { o p t } } \mathrm { o p t } _ { j ^ { \prime } } ^ { \prime } ( \mathrm { \small { \texttt { [ \theta ] } } } _ { y } ^ { \prime } , \mathrm { \small { \texttt { [ \varphi ] } } } _ { i } ^ { \prime , o p t } , \mathrm { \small { \texttt { [ \varphi ] } } } _ { 5 } ^ { \prime , o p t } ) ) } \\ & { \mathrm { U p d a t e \ } A _ { i } ^ { l o s s } \gets A _ { i } ^ { l o s s } + B _ { j ^ { \prime } + 1 } \cdot O _ { j ^ { \prime } } \cdot ( \nabla _ { \varphi _ { i } ^ { l o s s } } \nabla _ { \theta _ { j ^ { \prime } } ^ { \prime } } \ell _ { t + j ^ { \prime } } ^ { t r a i n } ( \mathrm { \small { \texttt { [ \theta ] } } } _ { y } ^ { \prime , o p t } ) } \\ & { \mathrm { C o m p u t e \ } B _ { j ^ { \prime } } \gets B _ { j ^ { \prime } + 1 } \cdot ( ( \nabla _ { \theta _ { j ^ { \prime } } } \mathrm { o p t } _ { j ^ { \prime } } ^ { \prime } ( \theta _ { j ^ { \prime } } ^ { \prime } , \varphi _ { i } ^ { o p t } , \mathrm { \small { \texttt { [ \theta ] } } } _ { \mathrm { s t o p } ( \theta _ { j ^ { \prime } } ) } ^ { \prime } ) ) ) + O _ { j ^ { \prime } } \cdot ( \nabla _ { \theta _ { j ^ { \prime } } ^ { \prime } } ^ { 2 } \ell _ { t + j ^ { \prime } } ^ { t r a i n } ( \theta _ { j ^ { \prime } } ^ { \prime } , \varphi _ { i } ^ { l o s s } ) ) ) } \\ &  \mathrm { c o m p u t e \ } B _ { j ^ { \prime } } \gets B _ { j ^ { \prime } + 1 } \cdot ( ( \nabla _ { \theta _ { j ^ { \prime } } } \mathrm { o p t } _ { j ^ { \prime } } ^ { \prime } ( \theta _ { j ^ { \prime } } ^ { \prime } , \varphi _ { i } ^ { o p t } , \mathrm { \small { \texttt { [ \theta ] } } } _ { \mathrm { s t o p } ( \theta _ { j ^ { \prime } } ) } ^ { \prime } ) ) + O _ { j ^ { \prime } } \cdot ( \nabla _ { \theta _ { j ^ { \prime } } ^ { \prime } } ^ { 2 }  \end{array}$   
+13:   
+14:   
+15: end for   
+16: Update meta-parameters $\varphi _ { \tau + i + 1 } \gets \mathbf { m e t a o p t } ( \varphi _ { \tau + i } , \mathbf { j o i n } ( A _ { i } ^ { o p t } , A _ { i } ^ { l o s s } ) )$   
+17: end for   
+18: return Updated meta-parameters $\varphi _ { \tau + I }$
+
+Each iteration through the loop defined by lines 1–17 does one gradient-based update of metaparameters $\varphi$ using the optimizer employed in line 16. Each such iteration, we first (line 3) copy the model and optimizer state (generally updated through some outer loop within which this update loop sits). We then (lines 4–7) compute a series of $J$ updates on a copy of the model, preserving the intermediate gradient computations $G _ { 0 } , \ldots , G _ { J - 1 }$ , intermediate model parameters ${ \bar { \theta } } _ { 0 } ^ { \prime } , \dots , \bar { \theta } _ { J } ^ { \prime }$ (sometimes confusingly referred to as “fast weights”, following Hinton $\&$ Plaut (1987), within the meta-learning literature), and all associated activations. These will be reused in the second stage (lines 10–15) to backpropagate higher-order gradients of the meta-loss, computed on line 9 through the optimization process that was run in lines 4–7. In particular, in lines 12 and 13, local (i.e. time step-specific) gradient calculations compute part of the gradient of $\nabla _ { \varphi _ { i } ^ { o p t } } \mathcal { L } ^ { v a l } ( \theta _ { J } ^ { \prime } )$ and $\nabla _ { \varphi _ { i } ^ { l o s s } } \mathcal { L } ^ { v a l } ( \theta _ { J } ^ { \prime } )$ , which is stored in accumulators which contain the exact respective gradients by the end of loop. What permits this efficient local computation is the dynamic programming calculation of the partial derivative $B _ { j ^ { \prime } } = \nabla _ { \theta _ { j ^ { \prime } } ^ { \prime } }$ as function of only $B _ { j ^ { \prime } + 1 }$ and timestep-specific gradients, implementing a second-order variant of BPTT through reverse-mode differentiation.
+
+# 3 EXAMPLES AND RELATED WORK
+
+In this section, we highlight some instances of meta-learning which are instances of GIMLI, before discussing related approaches involving support for nested optimization, with applications to similar problems. The aim is not to provide a comprehensive literature review, which space would not permit. Rather, in pointing out similarity under our GIMLI formulation, we aim to showcase that rich and diverse research has been done using this class of approaches, where yet more progress indubitably remains to be made. This is, we believe, the strongest motivation for the development of libraries such as the one we present in Section 4 to support the implementation of algorithms that fall under the general algorithm derived in Section 2.
+
+# 3.1 EXAMPLES
+
+Many of the papers referenced below contain excellent and thorough reviews of the literature most related to the type of meta-learning they approach. In the interest of brevity, we will not attempt such a review here, but rather focus on giving examples of a few forms of meta-learning that fit the GIMLI framework (and thus are supported by the library presented in Section 4), and briefly explain why.
+
+One popular meta-learning problem is that of learning to optimize hyperparameters through gradient-based methods (Bengio, 2000; Maclaurin et al., 2015; Luketina et al., 2016; Franceschi et al., 2017), as an alternative to grid/random search (Bergstra & Bengio, 2012) or Bayesian Optimization (Mockus et al., 1978; Pelikan et al., 1999; Bergstra et al., 2011; Snoek et al., 2012). Here, select continuous-valued hyperparameters are meta-optimized against a meta-objective, subject to the differentiability of the optimization step, and, where relevant, the loss function. This corresponds to Requirements $\mathrm { I I }$ and IIIa of Section 2.4 being met, i.e. GIMLI being run with select optimizer hyperparameters as part of $\varphi ^ { o p t }$ . To give a simple concrete example, in the approaches of Bengio (2000) and Maclaurin et al. (2015), the only meta-variable is the learning rate $\alpha$ , i.e. $\varphi = \varphi ^ { o p t } = \bar { \alpha }$ .
+
+A related problem is that of learning the optimizer wholesale as a parametric model (Hochreiter et al., 2001; Andrychowicz et al., 2016; Duan et al., 2016), typically based on recurrent architectures. Again, here the optimizer’s own parameters are the optimizer hyperparameters, and constitute the entirety of $\varphi ^ { o p t }$ as used within GIMLI. Requirements II and IIIa are trivially met through the precondition that such optimizers models have parameters with regard to which their output (and losses that are a function thereof) is differentiable. As a concrete example, in the work of Andrychowicz et al. (2016), an RNN with parameters $\phi$ is meta-learned, and models the updates made to parameters during training. In our formalism, this would correspond to setting as meta-variable the parameters of this update network, i.e. $\varphi ^ { o p t } = \phi$ .
+
+More recently, meta-learning approaches such as MAML (Finn et al., 2017; Antoniou et al., 2018) and its variants/extensions have sought to use higher-order gradients to meta-learn model/policy initializations in few-shot learning settings. In GIMLI, this corresponds to setting $\theta _ { 0 } = \varphi ^ { l o s s }$ , which then is not an explicit function of $\ell ^ { t r a i n }$ in Equation 3, but rather is implicitly its argument through updates to the inner model over the unrolled optimization. All requirements in Section 2.4 must be satisfied (save IIIa, with Requirement IIIb further entailing that $\bar { \ell } ^ { t r a i n }$ be defined such that the second derivative of the function with regard to $\theta$ exists (i.e. is non-zero).
+
+Finally, recent work by Chebotar et al. (2019) has introduced the $\mathrm { { \bf M L } ^ { 3 } }$ framework for learning unconstrained loss functions as parametric models, through exploiting second-order gradients of a meta-loss with regard to the parameters of the inner loss. This corresponds, in GIMLI, to learning a parametric model of the loss parameterized by $\varphi ^ { l o s s }$ .
+
+# 3.2 RELATED WORK
+
+In a sense, many if not all of the approaches discussed in Section 3.1 qualify as “related work”, but here we will briefly discuss approaches to the general problem of formalizing and supporting implementations of problems that fit within the nested optimization specified by GIMLI.
+
+The first is work by Franceschi et al. (2018) which describes how several meta-learning and hyperparameter optimization approaches can be cast as a bi-level optimization process, akin to our own formalization in 2.3. This fascinating and relevant work is highly complementary to the formalization and discussion presented in our paper. Whereas we focus on the requirements according to which gradient-based solutions to approaches based on nested optimization problems can be found in order to drive the development of a library which permits such approaches to be easily and scalably implemented, their work focuses on analysis of the conditions under which exact gradient-based solutions to bi-level optimization processes can be approximated, and what convergence guarantees exist for such guarantees. In this sense, this is more relevant to those who wish to analyze and extend alternatives to first-order approximations of algorithms such as MAML, e.g. see work of Nichol & Schulman (2018) or Rajeswaran et al. (2019).
+
+On the software front, the library learn2learn (Arnold et al., 2019) addresses similar problems to that which we will present in Section 4. This library focuses primarily on providing implementations of existing meta-learning algorithms and their training loops that can be extended with new models. In contrast, the library we present in Section 4 is “closer to the metal”, aiming to support the development of new meta-learning algorithms fitting the GIMLI definitions with as little resort to non-canonical PyTorch as possible. A recent parallel effort, Torchmeta (Deleu et al., 2019) also provides a library aiming to assist the implementation of meta-learning algorithms, supplying useful data-loaders for meta-training. However, unlike our approach described in 4, it requires re-implementation of models using their functional/stateless building blocks, and for users to reimplement the optimizers in a differentiable manner.
+
+# 4 THE unnamedlib LIBRARY
+
+In this section, we provide a high-level description of the design and capabilities of unnamedlib,4 a PyTorch (Paszke et al., 2017) library aimed at enabling implementations of GIMLI with as little reliance on non-vanilla PyTorch as possible. In this section, we first discuss the obstacles that would prevent us from implementing this in popular deep learning frameworks, how we overcame these in PyTorch to implement GIMLI. Additional features, helper functions, and other considerations when using/extending the library are provided in its documentation.
+
+# 4.1 OBSTACLES
+
+Many deep learning frameworks offer the technical functionality required to implement GIMLI, namely the ability to take gradients of gradients. However, there are two aspects of how we implement and train parametric models in such frameworks which inhibit our ability to flexibly implement Algorithm 1.
+
+The first obstacle is that models are typically implemented statefully (e.g. torch.nn in PyTorch, keras.layers in Keras (Chollet et al., 2015), etc.), meaning that the model’s parameters are encapsulated in the model implementation, and are implicitly relied upon during the forward pass. Therefore while such models can be considered as functions theoretically, they are not pure functions practically, as their output is not uniquely determined by their explicit input, and equivalently the parameters for a particular forward pass typically cannot be trivially overridden or supplied at call time. This prevents us from tracking and backpropagating over the successive values of the model parameters $\theta$ within the inner loop described by Equation 3, through an implicit or explicit graph.
+
+The second issue is that, as discussed at the end of Section 2.4 and in Appendix A, even though the operations used within popular optimizers are mathematically differentiable functions of the parameters, gradients, and select hyperparameters, these operations are not tracked in various framework’s implicit or explicit graph/gradient tape implementations when an optimization step is run. This is with good reason: updating model parameters in-place is memory efficient, as typically there is no need to keep references to the previous version of parameters. Ignoring the gradient dependency formed by allowing backpropagation through an optimization step essentially makes it safe to release memory allocated to historical parameters and intermediate model states once an update has been completed. Together, these obstacles essentially prevent us from practically satisfying Requirement II of Section 2.4.
+
+# 4.2 MAKING STATEFUL MODULES STATELESS
+
+As we wish to track and backpropagate through intermediate states of parameters during the inner loop, we keep a record of such states which can be referenced during the backward pass stage of the outer loop in Algorithm 1. The typical way this is done in implementations of meta-learning algorithms such as MAML is to rewrite a “stateless” version of the inner loop’s model, permitting the use, in each invocation of the model’s forward pass, of weights which are otherwise tracked on the gradient graph/tape. While this addresses the issue, it is an onerous and limiting solution, as exploring new models within such algorithms invariably requires their reimplementation in a stateless style. This typically prevents the researcher from experimenting with third-party codebases, complicated models, or those which requiring loading pre-trained weights, without addressing a significant and unwelcome engineering challenge.
+
+A more generic solution, permitting the use of existing stateful modules (including with pre-loaded activations), agnostic to the complexity or origin of the code which defines them, is to modify the run-time instance of the model’s parent class to render them effectively function, a technique often referred to as “monkey-patching”. The high-level function unnamedlib.monkeypatch() does this by taking as argument a torch.nn.Module instance and the structure of its nested sub-modules. As it traverses this structure, it clones the parent classes of submodule instances, leaving their functionality intact save for that of the forward method which implements the forward pass. Here, it replaces the call to the forward method with one which first replaces the stateful parameters of the submodule with ones provided as additional arguments to the patched forward, before calling the original class’s bound forward method, which will now used the parameters provided at call time. This method is generic and derived from first-principles analysis of the torch.nn.Module implementation, ensuring that any first or third-party implementation of parametric models which are subclasses of torch.nn.Module and do not abuse the parent class at runtime will be supported by this recursive patching process.
+
+# 4.3 MAKING OPTIMIZERS DIFFERENTIABLE
+
+Again, as part of our need to make the optimization process differentiable in order to satisfy Requirement II of Section 2.4, the typical solution is to write a version of SGD which does not modify parameters in-place, but treated as a differentiable function of the input parameters and hyperparameters akin to any other module in the training process. While this, again, is often considered a satisfactory solution in the meta-learning literature due to its simplicity, it too is limiting. Not only does the inability to experiment with other inner loop optimizers prevent research into the applicability of meta-learning algorithms to other optimization processes, the restriction to SGD also means that existing state-of-the-art methods used in practical domains cannot be extended using meta-learning methods such as those described in Section 3, lest they perform competitively when trained with SGD.
+
+Here, while less generic, the solution provided by the high-level function unnamedlib.get diff optim() is to render a PyTorch optimizer instance differentiable by mapping its parent class to a differentiable reimplementation of the instance’s parent class. The reimplementation is typically a copy of the optimizer’s step logic, with in-place operations being replaced with gradient-tracking ones (a process which is syntactically simple to execute in PyTorch).
+
+To this, we add wrapper code which copies the optimizer’s state, and allows safe branching off of it, to permit “unrolling” of the optimization process within an inner loop (cf. the recurrence from Equation 3) without modifying the initial state of the optimizer (e.g. to permit several such unrolls, or to preserve state if inner loop optimizer is used elsewhere in the outer loop). Most of the optimizers in torch.optim are covered by this method. Here too, a runtime modification of the parent optimizer class could possibly be employed as was done for torch.nn.Modules, but this would involve modifying Python objects at a far finer level of granularity. We find that supporting a wide and varied class of optimizers is a sufficient compromise to enable further research.5
+
+# 5 EXPERIMENTS
+
+In this section, we briefly present some results of experiments using select existing methods from Section 3.1, to show case how unnamedlib can be used to simply implement ablation studies and searches over model architectures, optimizers, and other aspects of an experiment. This could, naturally, be done without appeal to the library. However, in such cases, changing the model architecture or optimizer requires re-implementing the model functionally or optimization step differentiably. Here such changes require writing no new code (excluding the line where the model is defined).
+
+# 5.1 META-LEARNING LEARNING RATES WITH HIGHER GRANULARITY
+
+As the first application for unnamedlib, we set up a simple meta-learning task where we metaoptimize the learning rate. Employing a handcrafted annealing schedule for learning rates has been the de facto approach to improving a learning algorithm. While scheduled annealing can help to boost the final performance, it usually requires significant hand-tuning of the schedule. In contrast, we adjust learning rates automatically using meta-learning, which unnamedlib enables for arbitary models and optimizers.
+
+We take an image classification model DenseNet-BC( $k { = } 1 2$ ) (Huang et al., 2016), that provides competitive state-of-the-art results on CIFAR10, and modify its training procedure by replacing the multi-step annealing schedule of learning rate with a meta-optimizer. Specifically, we treat learning rate for each inner optimizer’s parameter group as a separate meta-parameter that we will metalearn. Doing so allows individual model parameters to have finer learning rates, that are adjusted automatically. The GIMLI algorithm provides for a clean implementation of such training procedure.
+
+![](images/df66c86a540cfae9842eb6d58d4b2ec1d50959f2875bfcb3a27a357c3d3744de.jpg)  
+Figure 1: Comparison of meta-learned learning rates against fixed and multi-step annealed for training DenseNet-BC( $_ { \mathrm { k = } 1 2 }$ ) on CIFAR10. We observe convergence near state-of-the-art with better sample complexity that using a hand-designed annealing schedule.
+
+We first train two baseline variants of DenseNet-BC( $\mathtt { k } = \mathtt { l } 2$ ) using setup from (Huang et al., 2016). In the first variant we keep the learning rate fixed to 0.1 for all 300 epochs, while the second configuration takes advantage of a manually designed multi-step annealing schedule, which drops learning rate by 10 after 150 and 225 epochs. For the meta-learning variant, we split the training set into two disjoint pieces, one for training and another for validation, in proportion of $9 9 : 1$ . We then use per parameter group learning rates (299 in total) for meta-optimization, initializing each learning rate to 0.1. We perform one meta-update step after each epoch, where we unroll inner optimizer for
+
+Table 1: Results from ablating $\mathbf { M A M L + + }$ architecture and inner optimizers. “Our base” results are from our VGG model trained with SGD in our $\mathbf { M A M L + }$ variant, and “our best” results show the best test accuracy found, with the best model/optimizer combination shown in the text below.   
+
+<table><tr><td rowspan="2"></td><td colspan="4">omniglot test accuracy</td><td colspan="2">miniImageNet test accuracy</td></tr><tr><td>5Way</td><td></td><td>20Way</td><td></td><td>5Way</td><td></td></tr><tr><td>Approach</td><td>1 Shot</td><td>5 Shot</td><td>1 Shot</td><td>5 Shot</td><td>1 Shot</td><td>5 Shot</td></tr><tr><td>MAML++ (Antoniou et al., 2018)</td><td>99.53 ± 0.26%</td><td>99.93 ± 0.09%</td><td>97.65 ± 0.05%</td><td>99.33±0.03%</td><td>52.15± 0.26%</td><td>68.32±0.44</td></tr><tr><td>MAML++ (Our base)</td><td>99.62 ± 0.08%</td><td>99.86 ± 0.02%</td><td>97.21 ± 0.11%</td><td>99.13 ±0.13%</td><td>56.33 ± 0.27%</td><td>75.13 ± 0.67%</td></tr><tr><td>MAML++ (Our best)</td><td>99.91 ± 0.05%</td><td>99.87 ± 0.03%</td><td>99.00 ± 0.33%</td><td>99.76 ± 0.01%</td><td>56.33 ± 0.27%</td><td>76.73 ± 0.52%</td></tr><tr><td></td><td>resnet-4+SGD</td><td>resnet-4+SGD</td><td>resnet-12+SGD</td><td>resnet-8+SGD</td><td>vgg+SGD</td><td>resnet-8+SGD</td></tr></table>
+
+15 steps using batches from the training set, and compute meta-test error on the validation set over 10 batches from the validation set. We use batch size of 16 for meta-update, rather than 64 as in the base training loop. We use Adam (Kingma & Ba, 2014) with default parameters as a choice for meta-optimizer. We average results over 3 random seeds. Figure 1 demonstrates that our method is able reach the state-of-the-art performance faster.
+
+# 5.2 ABLATING MAML’S MODEL ARCHITECTURE AND INNER OPTIMIZER
+
+The unnamedlib library enables the exploration of new MAML-like models and inner-loop optimizers, which historically has required non-trivial implementations of the fast-weights for the model parameters and inner optimizers as done in Antoniou et al. (2018); Deleu et al. (2019). These ablations can be important for squeezing the last few bits of accuracy on well-established tasks and baselines that are already near-optimal as shown in Chen et al. (2019), and is even more important for developing new approaches and tasks that deal with different kinds of data and require adaptation to be done over non-standard operations.
+
+To illustrate how easy unnamedlib makes these ablations, in this section we take a closer look at different model architecture and optimizer choices for the $\mathbf { M A M L + + }$ approach (Antoniou et al., 2018). MAML $^ { + + }$ uses a VGG network with a SGD inner optimizer for the the Omniglot (Lake et al., 2015) and Mini-Imagenet (Vinyals et al., 2016; Ravi & Larochelle, 2016) tasks. We start with the official $\mathbf { M A M L + + }$ code and evaluation procedure and use unnamedlib to ablate across VGG, ResNet, and DenseNet models and SGD and Adam optimizers. We provide more details about these in Appendix B. We denote the combination of model and inner optimizer choice with $< \mathrm { m o d e l } > + < \mathrm { o p t } >$ . One finding of standalone interest is that we have kept most of the features from $\mathbf { M A M L + }$ , except we significantly increase the base $\mathtt { V G G + S G D }$ performance by using batch normalization in training mode everywhere as in (Finn et al., 2017) instead of using per-timestep statistics and parameters as $\mathbf { M A M L + }$ proposes. In theory, this enables more inner optimization steps to be rolled out at test time, which otherwise is not possible with $\mathbf { M A M L + } +$ because of the pertimestep information, for simplicity in this paper we have not explored this and keep every algorithm, optimizer, and mode to five inner optimization steps. When using Adam as the inner optimizer, we initialize the first and second moment statistics to the statistics from the outer optimizer, which is also Adam, and learn per-parameter-group learning rates and rolling average $\beta$ coefficients. Our results in Table 1 show that we are able to push the accuracy of $\mathbf { M A M L + + }$ slightly up with this ablation. We note that this pushes the performance of $\mathbf { M A M L + } +$ closer to that of state-of-the-art methods such as LEO (Rusu et al., 2018). Appendix B shows our full experimental results, and we note that in some cases Adam slightly outperforms SGD for a particular model.
+
+# 6 CONCLUSION
+
+To summarize, we have presented GIMLI, a general formulation of a wide class of existing and potential meta-learning approaches, listed and proved the requirements that must be satisfied for such approaches to be possible, and specified a general algorithmic formulation of such approaches. We’ve described a lightweight library, unnamedlib, which extends PyTorch to enable the easy and natural implementation of such meta-learning approaches at scale. Finally we’ve demonstrated some of its potential applications. We hope to have made the case not only for the use of the mathematical and software tools we present here, but have also provided suitable encouragement for other researchers to use them and explore the boundaries of what can be done within this broad class of meta-learning approaches.
+
+# REFERENCES
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in neural information processing systems, pp. 3981–3989, 2016.
+
+Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018.
+
+Seb Arnold, Praateek Mahajan, Debajyoti Datta, and Ian Bunner. learn2learn. ´ https:// github.com/learnables/learn2learn, 2019.
+
+Yoshua Bengio. Gradient-based optimization of hyperparameters. Neural computation, 12(8):1889– 1900, 2000.
+
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012.
+
+James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Advances in neural information processing systems, pp. 2546–2554, 2011.
+
+Yevgen Chebotar, Artem Molchanov, Sarah Bechtle, Ludovic Righetti, Franziska Meier, and Gaurav Sukhatme. Meta-learning via learned loss. arXiv preprint arXiv:1906.05374, 2019.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification, 2019.
+
+Franc¸ois Chollet et al. Keras, 2015.
+
+Tristan Deleu, Tobias Wurfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio. Torch- ¨ meta: A Meta-Learning library for PyTorch, 2019. URL https://arxiv.org/abs/1909. 06576. Available at: https://github.com/tristandeleu/pytorch-meta.
+
+Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.
+
+John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1126–1135. JMLR. org, 2017.
+
+Luca Franceschi, Michele Donini, Paolo Frasconi, and Massimiliano Pontil. Forward and reverse gradient-based hyperparameter optimization. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1165–1173. JMLR. org, 2017.
+
+Luca Franceschi, Paolo Frasconi, Saverio Salzo, Riccardo Grazzi, and Massimilano Pontil. Bilevel programming for hyperparameter optimization and meta-learning. arXiv preprint arXiv:1806.04910, 2018.
+
+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.
+
+Geoffrey E Hinton and David C Plaut. Using fast weights to deblur old memories. In Proceedings of the ninth annual conference of the Cognitive Science Society, pp. 177–186, 1987.
+
+Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pp. 87–94. Springer, 2001.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. CoRR, 2016.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Diederik P 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.
+
+Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015.
+
+Jelena Luketina, Mathias Berglund, Klaus Greff, and Tapani Raiko. Scalable gradient-based tuning of continuous regularization hyperparameters. In International conference on machine learning, pp. 2952–2960, 2016.
+
+Dougal Maclaurin, David Duvenaud, and Ryan Adams. Gradient-based hyperparameter optimization through reversible learning. In International Conference on Machine Learning, pp. 2113– 2122, 2015.
+
+Jonas Mockus, Vytautas Tiesis, and Antanas Zilinskas. The application of bayesian methods for seeking the extremum. Towards global optimization, 2(117-129):2, 1978.
+
+Alex Nichol and John Schulman. Reptile: a scalable metalearning algorithm. arXiv preprint arXiv:1803.02999, 2, 2018.
+
+Boris Oreshkin, Pau Rodr´ıguez Lopez, and Alexandre Lacoste. Tadam: Task dependent adaptive ´ metric for improved few-shot learning. In Advances in Neural Information Processing Systems, pp. 721–731, 2018.
+
+Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002.
+
+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 NIPS Autodiff Workshop, 2017.
+
+Martin Pelikan, David E Goldberg, and Erick Cantu-Paz. Boa: The bayesian optimization algorithm. ´ In Proceedings of the 1st Annual Conference on Genetic and Evolutionary Computation-Volume 1, pp. 525–532. Morgan Kaufmann Publishers Inc., 1999.
+
+Aravind Rajeswaran, Chelsea Finn, Sham Kakade, and Sergey Levine. Meta-learning with implicit gradients. arXiv preprint arXiv:1909.04630, 2019.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. CoRR, 2016.
+
+Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pp. 400–407, 1951.
+
+David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning internal representations by error propagation. Technical report, California Univ San Diego La Jolla Inst for Cognitive Science, 1985.
+
+Andrei A Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. Meta-learning with latent embedding optimization. arXiv preprint arXiv:1807.05960, 2018.
+
+Jurgen Schmidhuber. ¨ Evolutionary principles in self-referential learning, or on learning how to learn: the meta-meta-... hook. PhD thesis, Technische Universitat M¨ unchen, 1987. ¨
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012.
+
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, pp. 3630–3638, 2016.
+
+Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992.
+
+# A OPTIMIZER DIFFERENTIABILITY
+
+A.1 SGD
+
+$\nabla _ { \varphi } \theta _ { t + 1 } = \nabla _ { \varphi } \mathbf { S } \mathbf { G } \mathbf { D } ( \theta _ { t } , G _ { t } ) = \nabla _ { \varphi } [ \theta _ { t } - \alpha G _ { t } ] = \nabla _ { \varphi } \theta _ { t } - G _ { t } \nabla _ { \varphi } \alpha - \alpha \nabla _ { \varphi } G _ { t }$ where $\alpha$ is the learning rate, and $\nabla _ { \varphi } \alpha$ is defined iff $\alpha \subseteq \varphi$ else $G _ { t } \nabla _ { \varphi } \alpha = 0$
+
+$$
+\nabla _ { \theta _ { t } } \theta _ { t + 1 } = \nabla _ { \theta _ { t } } \mathbf { S } \mathbf { G } \mathbf { D } ( \theta _ { t } , G _ { t } ) = \nabla _ { \theta _ { t } } [ \theta _ { t } - \alpha G _ { t } ] = \nabla _ { \theta _ { t } } \theta _ { t } - \alpha \nabla _ { \theta _ { t } } G _ { t } = 1 - \alpha \nabla _ { \theta _ { t } } ^ { 2 } \ell _ { t } ^ { t r a i n } ( \theta _ { t } , \varphi )
+$$
+
+A.2 ADAGRAD
+
+$$
+\begin{array} { r l } & { \nabla _ { \varphi } \theta _ { t + 1 } = \nabla _ { \varphi } \mathbf { A } \mathbf { d a g r a d } ( \theta _ { t } , G _ { t } ) = \nabla _ { \varphi } [ \theta _ { t } - \frac { \eta } { \sqrt { \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } G _ { t } ] } \\ & { \qquad = \nabla _ { \varphi } \theta _ { t } - \frac { \eta \nabla _ { \varphi } G _ { t } } { \sqrt { \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } - \frac { G _ { t } \nabla _ { \varphi } \eta } { \sqrt { \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } + \frac { \eta G _ { t } \sum _ { i = 1 } ^ { t } G _ { i } \nabla _ { \varphi } G _ { i } } { \left( \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } \right) ^ { \frac { 3 } { 2 } } } } \end{array}
+$$
+
+where $\eta$ is the global learning rate, and $\nabla _ { \varphi } \eta$ is defined iff $\eta \subseteq \varphi$ else $\frac { \mathrm { \Delta } G _ { t } \nabla _ { \varphi } \eta } { \sqrt { \sum _ { i = 1 } ^ { t } { G _ { i } ^ { 2 } } } } = 0$
+
+$$
+\begin{array} { r l r } & { \nabla _ { \theta _ { t } } \theta _ { t + 1 } = \nabla _ { \theta _ { t } } \mathbf { A } \mathbf { d a } \mathbf { g r a d } ( \theta _ { t } , G _ { t } ) = \nabla _ { \theta _ { t } } [ \theta _ { t } - \frac { \eta } { \sqrt { \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } G _ { i } ] } & \\ & { } & { \qquad = \nabla _ { \theta _ { t } } \theta _ { t } - \frac { \eta \nabla _ { \theta _ { t } } G _ { t } } { \sqrt { \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } + \frac { \eta G _ { t } ^ { 2 } \nabla _ { \theta _ { t } } G _ { t } } { \left( \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } \right) ^ { \frac { 3 } { 2 } } } } \\ & { } & { \qquad = 1 - \frac { \eta \nabla _ { \theta _ { t } } ^ { 2 } \ell _ { t } ^ { t r a i n } \left( \theta _ { t } , \varphi \right) } { \sqrt { \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } + \frac { \eta G _ { t } ^ { 2 } \nabla _ { \theta _ { t } } ^ { 2 } \ell _ { t } ^ { t r a i n } \left( \theta _ { t } , \varphi \right) } { \left( \sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } \right) ^ { \frac { 3 } { 2 } } } } \end{array}
+$$
+
+# B MAML $^ { + + }$ EXPERIMENTS: ADDITIONAL INFORMATION
+
+Table 2 shows all of the architectures and optimizers we ablated. The table is missing some rows as we only report the results that successfully completed running three seeds within three days on our cluster.
+
+We use the following model architectures, which closely resemble the vanilla PyTorch examples for these architectures but are modified to be smaller for the few-shot classification setting:
+
+• vgg is the VGG architecture (Simonyan & Zisserman, 2014) variant used in MAML $^ { + + }$ (Antoniou et al., 2018)   
+• resnet $- \mathbb { N }$ is the ResNet architecture (He et al., 2016). resnet-4 corresponds to the four blocks having just a single layer, and resnet-8 and resnet-12 have respectively 2 and 3 layers in each block   
+• densenet-8 is the DenseNet architecture (Huang et al., 2017) with 2 layers in each block
+
+We follow TADAM (Oreshkin et al., 2018) and do not use the initial convolutional projection layer common in the full-size variants of the ResNet and DenseNet.
+
+We can also visualize how the learning rates and rolling momentum terms (with Adam) change over time when they are being learned. We show this in Figure 2 and Figure 3 for the 20-way 1-shot Omniglot experiment with the resnet-4 architecture, which is especially interesting as Adam outperforms SGD in this case. We find that most of the SGD learning rates are decreased to near-zero except for a few select few that seem especially important for the adaptation. Adam exhibits similar behavior with the learning rates where most except for a select for are zeroed for the adaptation, and the rolling moment coefficients are particularly interesting where the first moment coefficient $\beta _ { 1 }$ becomes relatively evenly spread throughout the space while $\beta _ { 2 }$ splits many parameter groups between low and high regions of the space.
+
+Table 2: Full MAML $^ { + + }$ model and inner optimizer sweep search results.   
+
+<table><tr><td colspan="5"></td><td rowspan="2">mean acc</td><td rowspan="2">std</td></tr><tr><td>dataset</td><td>nway</td><td>kshot</td><td>model</td><td>inner_optim</td></tr><tr><td>mini_imagenet_full_size</td><td>5</td><td>1</td><td>densenet-8</td><td>SGD</td><td>46.08</td><td>1.40</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>51.06</td><td>1.51</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>Adam</td><td>49.71</td><td>3.71</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>54.36</td><td>0.23</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>54.16</td><td>1.35</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>47.93</td><td>11.64</td></tr><tr><td></td><td></td><td>5</td><td>densenet-8</td><td>SGD</td><td>56.33</td><td>0.27</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>65.29</td><td>0.98</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>37.40</td><td>3.64</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>SGD</td><td>69.14</td><td>3.19</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>76.33</td><td>0.71</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>74.48</td><td>0.77</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>68.03</td><td>15.19</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>76.73</td><td>0.52</td></tr><tr><td>omniglot_dataset</td><td></td><td></td><td>vgg</td><td>Adam SGD</td><td>72.82</td><td>2.36</td></tr><tr><td></td><td>5</td><td>1</td><td>densenet-8</td><td>SGD</td><td>75.13</td><td>0.67</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>SGD</td><td>99.54</td><td>0.33</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>99.91</td><td>0.05</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>SGD</td><td>99.62</td><td>0.08</td></tr><tr><td></td><td></td><td>5</td><td>densenet-8</td><td>SGD</td><td>99.62</td><td>0.08</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>99.86</td><td>0.05</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>SGD</td><td>99.87</td><td>0.03</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>99.86</td><td>0.04</td></tr><tr><td></td><td>20</td><td>1</td><td></td><td>SGD</td><td>99.86</td><td>0.02</td></tr><tr><td></td><td></td><td></td><td>densenet-8</td><td>SGD</td><td>93.20</td><td>0.32</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>99.00</td><td>0.33</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>Adam</td><td>98.31</td><td>0.09</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>96.31</td><td>0.15</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>98.50</td><td>0.15</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>96.15</td><td>0.16</td></tr><tr><td></td><td></td><td>5</td><td></td><td>SGD</td><td>97.21</td><td>0.11</td></tr><tr><td></td><td></td><td></td><td>densenet-8</td><td>SGD</td><td>97.24</td><td>0.26</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>99.69</td><td>0.17</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>Adam</td><td>99.44</td><td>0.23</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>99.71</td><td>0.03</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>99.76</td><td>0.01</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>98.74</td><td>0.04</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>99.13</td><td>0.13</td></tr></table>
+
+![](images/6573403018cf03c30c15107e58dd5e9277846f53a29dc9c40681bc98921a5eb0.jpg)  
+Figure 2: The learning rates during a training run of a VGG network with SGD as the inner optimizer for 20-way 1-shot mini-imagenet classification. The colors show the parameter groups within the model.
+
+![](images/413e8d783bc7dd1584876aef0fb4e6d9909db56605bed7206b3da8d374e6130e.jpg)  
+Figure 3: The learning rates during a training run of a VGG network with Adam as the inner optimizer for 20-way 1-shot mini-imagenet classification. The colors show the parameter groups within the model.

parse/train/BygWRaVYwH/BygWRaVYwH_content_list.json

@@ -0,0 +1,1786 @@
+[
+    {
+        "type": "text",
+        "text": "GENERALIZED INNER LOOP META-LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            98,
+            730,
+            121
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            145,
+            398,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            210,
+            544,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Many (but not all) approaches self-qualifying as “meta-learning” in deep learning and reinforcement learning fit a common pattern of approximating the solution to a nested optimization problem. In this paper, we give a formalization of this shared pattern, which we call GIMLI, prove its general requirements, and derive a general-purpose algorithm for implementing similar approaches. Based on this analysis and algorithm, we describe a library of our design, unnamedlib, which we share with the community to assist and enable future research into these kinds of meta-learning approaches. We end the paper by showcasing the practical applications of this framework and library through illustrative experiments and ablation studies which they facilitate. ",
+        "bbox": [
+            233,
+            241,
+            764,
+            381
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            407,
+            336,
+            424
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Although it is by no means a new subfield of machine learning research (see e.g. Schmidhuber, 1987; Bengio, 2000; Hochreiter et al., 2001), there has recently been a surge of interest in metalearning (e.g. Maclaurin et al., 2015; Andrychowicz et al., 2016; Finn et al., 2017). This is due to the methods meta-learning provides, amongst other things, for producing models that perform well beyond the confines of a single task, outside the constraints of a static dataset, or simply with greater data efficiency or sample complexity. Due to the wealth of options in what could be considered “meta-” to a learning problem, the term itself may have been used with some degree of underspecification. However, it turns out that many meta-learning approaches, in particular in the recent literature, follow the pattern of optimizing the “meta-parameters” of the training process by nesting one or more inner loops in an outer training loop. Such nesting enables training a model for several steps, evaluating it, calculating or approximating the gradients of that evaluation with respect to the meta-parameters, and subsequently updating these meta-parameters. ",
+        "bbox": [
+            174,
+            440,
+            825,
+            606
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "This paper makes three contributions. First, we propose a formalization of this general process, which we call Generalized Inner Loop Meta-Learning (GIMLI), and show that it subsumes several recent approaches. The proposed formalism allows us to describe the meta-optimization process in general terms and analyse its requirements. Second, we derive a general algorithm that supports the implementation of various kinds of meta-learning fitting within the GIMLI framework and its requirements. Third, based on this analysis and algorithm, we describe a lightweight PyTorch library that enables the straightforward implementation of any meta-learning approach that fits within the GIMLI framework in canonical PyTorch, such that existing codebases require minimal changes, supporting third party module implementations and a variety of optimizers. Through a set of indicative experiments, we showcase the sort of research directions that are facilitated by our formalization and the corresponding library. ",
+        "bbox": [
+            174,
+            613,
+            825,
+            766
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The overarching aim of this paper is not—emphatically—to purport some notion of ownership or precedence in any sense over existing efforts by virtue of having proposed a unifying formulation. Rather, in pointing out similarities under such unification, it provides theoretical and practical tools for facilitating further research in this exciting domain. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            829
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 GENERALIZED INNER LOOP META-LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            849,
+            591,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Whereby “meta-learning” is taken to mean the process of “learning to learn”, we can describe it as a nested optimization problem according to which an outer loop optimizes meta-variables controlling the optimization of model parameters within an inner loop. The aim of the outer loop should be to improve the meta-variables such that the inner loop produces models which are more suitable according to some criterion. In this section, we will formalize this process, which we call Generalized Inner Loop Meta-Learning (GIMLI). We will define our terms in Section 2.1, give a formal description of the inner and outer loop’s respective optimization problems in Section 2.2 and 2.3, followed by a description and proof of the requirements under which the process can be run in Section 2.4. Finally, in Section 2.5 we describe an algorithm which permits an efficient and exact implementation of GIMLI, agnostic to the model and optimizers used. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 DEFINITIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            219,
+            305,
+            233
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let us assume we wish to train a model parameterized by $\\theta$ . Let $\\varphi$ describe some collection of possibly unrelated “meta-parameters” describing some aspect of the process by which we train our model. These could be, for example the learning rate or some other real-valued hyperparameters, task loss weights in multi-task learning, or perhaps the initialization of the model weights at the beginning of training. For disambiguation, we will refer to the subset of $\\varphi$ describing optimization parameters by $\\varphi ^ { o p t }$ , and those meta-parameters which parameterize aspects of the training loss calculation at every step (e.g. the loss itself, the task mixture, regularization terms, etc) by $\\varphi ^ { l o \\overline { { s } } s }$ , i.e. $\\varphi = \\varphi ^ { o p t } \\cup \\varphi ^ { l o s s }$ . We will give several concrete examples in Section 3. ",
+        "bbox": [
+            174,
+            246,
+            825,
+            358
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathcal { L } ^ { t r a i n }$ be a function of $\\theta$ and $\\varphi$ corresponding to the overall training objective we seek to minimize directly or indirectly (e.g. via an upper bound, a Monte Carlo estimate of an expectation, etc). Other elements of the objective such as the dataset, and hyperparameters or other aspects of training not covered by $\\varphi$ , are assumed to be implicit and held fixed in $\\mathcal { L } ^ { t r a i n }$ for notational simplicity. With this, the process by which we train a model to obtain test-time parameters $\\theta ^ { * }$ can be formalized as shown in Equation $1 ^ { 1 }$ . ",
+        "bbox": [
+            173,
+            364,
+            825,
+            448
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6cedd4080bf54fcf0839b383d84659a5a7effca6c76b3408ff91a545e5598e28.jpg",
+        "text": "$$\n\\theta ^ { * } = \\operatorname * { a r g m i n } ( \\theta ; \\mathcal { L } ^ { t r a i n } ( \\theta , \\varphi ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            393,
+            455,
+            602,
+            473
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We assume that this search will be performed using an iterative gradient-based method such as some form of gradient descent as formalized in Section 2.2, and thus that the derivative $\\nabla _ { \\boldsymbol { \\theta } } \\mathcal { L } ^ { t r a i n } ( \\boldsymbol { \\theta } , \\boldsymbol { \\varphi } )$ exists, as an obvious requirement. ",
+        "bbox": [
+            174,
+            481,
+            825,
+            523
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, let $\\mathcal { L } ^ { v a l }$ be a function exclusively of $\\theta$ (except the specific case where $\\varphi$ describes some aspect of the model, e.g. initialization, as is done in MAML (Finn et al., 2017)) describing some objective we wish to measure the post-training performance of the model against. This could be a validation set from the same task the model was trained on, from a collection of other tasks, or some other measure of the quality of the model parameterized by $\\theta ^ { * }$ . Typically, the aforementioned iterative process is not run to convergence, but rather to the point where an intermediate set of model parameters is considered satisfactory according to some criterion (e.g. best model under $\\mathcal { L } ^ { v a l }$ for a fixed budget of training steps, or after no improvement is seen for a certain number of training steps, etc.), and these intermediate parameters will serve as $\\theta ^ { * }$ . ",
+        "bbox": [
+            173,
+            530,
+            825,
+            655
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            674,
+            285,
+            688
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The process by which we typically approximate $\\theta ^ { * }$ against $\\mathcal { L } ^ { t r a i n }$ decomposes into a sequence of updates of $\\theta$ . At timestep $t$ , we compute $\\theta _ { t + 1 }$ from $\\theta _ { t }$ by first computing a step-specific loss $\\ell _ { t } ^ { t r a i n } ( \\theta _ { t } , \\varphi ^ { l o s s } )$ . Note that this loss may itself also be a function of step-specific factors, such as the training data used for that timestep, which we leave implicit here for notational simplicity. Following this, we typically compute or approximate (e.g. as in reinforcement learning) the gradients $\\nabla _ { \\theta _ { t } } \\mathcal { \\bar { \\ell } } _ { t } ^ { t r a i n } ( \\theta _ { t } , \\varphi ^ { \\bar { l } \\ o s s } )$ of this loss with regard to $\\theta _ { t }$ , by using algorithms such as backpropagation (Rumelhart et al., 1985). We then typically use an optimizer to “apply” these gradients to the parameters $\\theta _ { t }$ to obtain updated parameters $\\theta _ { t + 1 }$ . As such, optimization processes such as e.g. Adagrad (Duchi et al., 2011) may be stateful, in that they exploit gradient history to produce adaptive “local” learning rates. Because some aspects of the optimization process may be covered by our choice of $\\varphi$ , we denote this optimization step at time-step $t$ by $\\mathbf { o p t } _ { t }$ as shown in Equation 2, where timestep-specific attributes of the optimizer are left implicit by our use of the step subscript. ",
+        "bbox": [
+            173,
+            699,
+            825,
+            839
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            169,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38ea786f4ddd8c8207e0d4df0146d7a94ae49cb681baa883007bbc204e2653c5.jpg",
+        "text": "$$\n\\theta _ { t + 1 } =  { \\mathbf { o p t } } _ { t } ( \\theta _ { t } , \\varphi ^ { o p t } , G _ { t } ) \\quad \\mathrm { w h e r e } \\quad G _ { t } = \\nabla _ { \\theta _ { t } } \\ell _ { t } ^ { t r a i n } ( \\theta _ { t } , \\varphi ^ { l o s s } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            287,
+            136,
+            710,
+            154
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For example, where we might use SGD as an optimizer, with the learning-rate being a meta-variable $\\varphi ^ { o p t }$ , we could instantiate equation 2 as follows: ",
+        "bbox": [
+            169,
+            157,
+            825,
+            185
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/981358e70bd19a6a53a689d43402744d69acb24736302b35c90e35f7f65602ed.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbf { o p t } _ { t } ( \\theta _ { t } , \\varphi ^ { o p t } , G _ { t } ) : = \\theta _ { t } - \\varphi ^ { o p t } \\cdot G _ { t } \\quad \\mathrm { w h e r e } \\quad G _ { t } = \\nabla _ { \\theta _ { t } } \\ell _ { t } ^ { t r a i n } \\big ( \\theta _ { t } , \\varphi ^ { l o s s } \\big ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            253,
+            189,
+            743,
+            209
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The estimation of $\\theta ^ { * }$ from Equation 1 using $T + 1$ training updates according to Equation 2 yields a double recurrence in both $\\theta _ { t }$ and $G _ { t }$ (as it is a function of $\\theta _ { t }$ , as outlined in Equation 3). ",
+        "bbox": [
+            173,
+            218,
+            823,
+            247
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ba8954ae0891801adfa0120feba763987144fe95492a322fd42f95474caa6a9b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\theta ^ { * } \\approx \\mathbf { o p t } _ { T } ( \\theta _ { T } , \\varphi ^ { o p t } , G _ { T } ) = \\mathbf { o p t } _ { T } ( P _ { T } , \\varphi ^ { o p t } , \\nabla _ { \\theta _ { T } } \\ell _ { T } ^ { t r a i n } ( P _ { T } , \\varphi ^ { l o s s } ) ) } \\\\ & { P _ { T } = \\mathbf { o p t } _ { T - 1 } ( \\theta _ { T - 1 } , \\varphi ^ { o p t } , G _ { T - 1 } ) = \\mathbf { o p t } _ { T - 1 } ( P _ { T - 1 } , \\varphi ^ { o p t } , \\nabla _ { \\theta _ { T - 1 } } \\ell _ { T - 1 } ^ { t r a i n } ( P _ { T - 1 } , \\varphi ^ { l o s s } ) ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            251,
+            808,
+            294
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/827b01dccd43d7d987d7c87aa407c0623051f1ff7f46fe0ddb01fbf115fc965c.jpg",
+        "text": "$$\nP _ { 1 } = \\mathbf { o p t } _ { 0 } ( \\theta _ { 0 } , \\varphi ^ { o p t } , G _ { 0 } ) = \\mathbf { o p t } _ { 0 } ( \\theta _ { 0 } , \\varphi ^ { o p t } , \\nabla _ { \\theta _ { 0 } } \\ell _ { 0 } ^ { t r a i n } ( \\theta _ { 0 } , \\varphi ^ { l o s s } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            320,
+            669,
+            339
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "From this we see that the optimization process used to train a variety of model types, with a variety of optimization methods, can be described as a function yielding test-time model parameters $\\theta ^ { * }$ potentially as a function of parameter history $\\theta _ { 1 } , \\ldots , \\theta _ { T }$ and of meta-parameters $\\varphi$ (if any exist). While this may seem like a fairly trivial formalization of a ubiquitous training process, we will see in Section 2.4 that if a few key requirements are met, this process can be nested as the inner loop within an outer loop containing—amongst other things—a meta-training process. From this process, described in Section 2.3, we estimate values of $\\varphi$ which improve our training process against some external metric. ",
+        "bbox": [
+            173,
+            349,
+            825,
+            462
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 META-TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            477,
+            334,
+            492
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We now describe the outer loop optimization problem which wraps around the inner loop described in Section 2.2. Through this process, we seek a value $\\varphi ^ { * }$ which ensures that the training process $\\mathcal { L } ^ { t r a i n } ( \\theta , \\varphi ^ { * } )$ produces parameters $\\theta ^ { * }$ which perform best against some metric $\\mathcal { L } ^ { v a l } ( \\theta ^ { * } )$ which we care about. The formalization and decomposition of this “meta-training process” into nested optimization problems is shown in Equation 4. ",
+        "bbox": [
+            173,
+            502,
+            825,
+            574
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1b9360fc2f73466ab8d40e973ced63bd5bb9a786a92c81c374c0dde43b9421f7.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\boldsymbol { \\varphi } ^ { * } = \\operatorname * { a r g m i n } \\left( \\boldsymbol { \\varphi } ; \\mathcal { L } ^ { v a l } ( \\boldsymbol { \\theta } ^ { * } ) \\right) } \\\\ & { \\quad = \\operatorname * { a r g m i n } \\left( \\boldsymbol { \\varphi } ; \\mathcal { L } ^ { v a l } \\left( \\operatorname * { a r g m i n } \\left( \\boldsymbol { \\theta } ; \\mathcal { L } ^ { t r a i n } \\left( \\boldsymbol { \\theta } , \\boldsymbol { \\varphi } \\right) \\right) \\right) \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            577,
+            669,
+            618
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we introduce a formalization of an iterative process allowing us to approximate this nested optimization process. Furthermore, we describe a general iterative algorithm by which the process in Equation 4 can be approximated by gradient-based methods while jointly estimating $\\theta ^ { * }$ according to the process in Equation 1. ",
+        "bbox": [
+            173,
+            619,
+            825,
+            676
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An iterative process by which we can estimate $\\varphi ^ { * }$ given Equation 4 following the sort of decomposition of the training process described Equation 1 into the training process described in Equations $2 -$ 3 is described below. Essentially, an estimate of $\\theta ^ { * }$ is obtained following $T + 1$ steps training as outlined in Equation 3, which is then evaluated against $\\mathcal { L } ^ { v a l }$ . The gradient of this evaluation, $\\nabla _ { \\varphi } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } )$ is then obtained through backpropagation, and used to update $\\varphi$ . Using $\\tau$ as time-step counter to symbolize the time-scale being different from that used in the “inner loop”, we formalize this update in Equation 5 where metaopt $\\tau$ denotes the optimization process used to update $\\varphi _ { \\tau }$ using $M _ { \\tau }$ at that time-step. ",
+        "bbox": [
+            173,
+            681,
+            825,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8ad3d5942bdeab6e616a7a2e185b535f51eafb50e54e12aac7a410c2461e8809.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\varphi _ { \\tau + 1 } = \\mathbf { m e t a o p t } _ { \\tau } ( \\varphi _ { \\tau } , M _ { \\tau } ) \\quad \\mathrm { w h e r e } \\quad M _ { \\tau } = \\nabla _ { \\varphi _ { \\tau } } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } ) } \\\\ & { \\qquad = \\mathbf { m e t a o p t } _ { \\tau } ( \\varphi _ { \\tau } , \\nabla _ { \\varphi _ { \\tau } } \\mathcal { L } ^ { v a l } ( \\mathbf { o p t } _ { T } ( P _ { T } , \\varphi ^ { o p t } , G _ { T } ) ) ) } \\\\ & { \\mathrm { r e } P _ { T } = \\mathbf { o p t } _ { T - 1 } ( P _ { T - 1 } , \\varphi ^ { o p t } , \\nabla _ { \\theta _ { T - 1 } } \\ell _ { T - 1 } ^ { t r a i n } ( P _ { T - 1 } , \\varphi ^ { l o s s } ) ) } \\\\ & { \\qquad \\vdots } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            816,
+            717,
+            905
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 KEY REQUIREMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            362,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For gradient-based meta-learning as formalized in Section 2.3—in particular through the process formalized in Equation 5—to be possible, a few key requirements must be met. We enumerate them here, and then discuss the conditions under which they are met, either analytically or through choice of model, loss function, or optimizer. ",
+        "bbox": [
+            173,
+            130,
+            825,
+            185
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "I. $\\mathcal { L } ^ { v a l }$ is a differentiable function of its input, i.e. the derivative $\\nabla _ { \\theta ^ { * } } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } )$ exists. ",
+        "bbox": [
+            187,
+            199,
+            746,
+            215
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "II. The optimization process opt in Equation 2 is a differentiable2 function of $\\theta$ and $G ^ { 3 }$ ",
+        "bbox": [
+            186,
+            219,
+            764,
+            236
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "III. Either or both of the following conditions hold: ",
+        "bbox": [
+            181,
+            239,
+            519,
+            255
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "(a) there exist continuous optimization hyperparameters (e.g. a learning rate $\\alpha$ ) covered by $\\varphi ^ { o p t }$ (e.g. $\\alpha \\subseteq \\varphi ^ { o p t } ,$ ) and opt in Equation 2 is a differentiable function of $\\varphi ^ { o p t }$ , or   \n(b) the gradient $G _ { t }$ for one or more time-steps in Equations 1–3 is a function of $\\varphi ^ { l o s s }$ (i.e. the derivative $\\nabla _ { \\varphi ^ { l o s s } } \\ell ^ { t r a i n } ( \\theta , \\varphi ^ { l o s s } )$ exists). ",
+        "bbox": [
+            210,
+            258,
+            825,
+            320
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the remainder of this section, we show that based on the assumptions outlined in Section 2.1, namely the existence of gradients on the validation objective $\\mathcal { L } ^ { v a l }$ with regard to model parameters $\\theta$ and of gradients on the training objective $\\mathcal { L } ^ { t r a i n }$ with regard to both model parameters $\\theta$ and metaparameters $\\varphi$ , there exist gradients on the validation objective $\\mathcal { L } ^ { v a l }$ with regard to $\\varphi$ . We will then, in the next section, demonstrate how to implement this process by specifying an update algorithm for meta-variables. ",
+        "bbox": [
+            173,
+            333,
+            825,
+            416
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Implementing an iterative process as described in Equation 5 will exploit the chain rule for partial derivatives in order to run backpropagation. The structure of the recurrence means we need to ensure that $\\nabla _ { \\theta _ { t } } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } )$ exists for $t \\in \\{ 0 , \\ldots , T \\}$ in order to compute, for all such $\\theta _ { t }$ , gradient paths $( \\nabla _ { \\theta _ { t } } \\mathcal { L } ^ { v \\bar { a } l } ( \\theta ^ { * } ) ) \\cdot ( \\nabla _ { \\varphi } \\theta _ { t } )$ . We can prove this exists in virtue of the chain rule for partial derivatives and the requirements above: ",
+        "bbox": [
+            174,
+            422,
+            825,
+            493
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. By the chain rule, $\\nabla _ { \\theta _ { t } } \\mathcal { L } ^ { v a l } ( \\theta _ { * } ) = \\left( \\nabla _ { \\theta ^ { * } } \\mathcal { L } ^ { v a l } ( \\theta _ { * } ) \\right) \\cdot \\left( \\nabla _ { \\theta _ { t } } \\theta ^ { * } \\right)$ exists if $\\nabla _ { \\theta ^ { * } } \\mathcal { L } ^ { v a l } ( \\theta _ { * } )$ exists (and it does, by Requirement I) and $\\nabla _ { \\theta _ { t } } \\theta ^ { * } = \\nabla _ { \\theta _ { t } } \\theta _ { T + 1 }$ exists. 2. Idem, $\\nabla _ { \\theta _ { t } } \\theta _ { T + 1 } = ( \\nabla _ { \\theta _ { t + 1 } } \\theta _ { T + 1 } ) \\cdot \\left( \\nabla _ { \\theta _ { t } } \\theta _ { t + 1 } \\right)$ exists by recursion over $t$ if for all $i \\in [ 1 , T ]$ , $\\nabla _ { { \\boldsymbol { \\theta } } _ { i } } \\theta _ { i + 1 }$ exists, which is precisely what Requirement $\\mathrm { I I }$ guarantees. ",
+        "bbox": [
+            202,
+            503,
+            825,
+            569
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Therefore $\\nabla _ { \\theta _ { t } } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } )$ exists for $t \\in \\{ 0 , \\ldots , T \\}$ , leaving us to demonstrate that $\\nabla _ { \\varphi } \\theta _ { t }$ is defined for all relevant values of $t$ as a consequence of requirements I–III. We separately consider the case of $\\varphi ^ { l o s s }$ and $\\varphi ^ { o p t }$ as defined in Section 2.1: ",
+        "bbox": [
+            174,
+            579,
+            826,
+            622
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "1. For $\\nabla _ { \\varphi ^ { o p t } } \\theta _ { t }$ , the gradients trivially exist as a consequence of Requirement IIIa. 2. For $\\nabla _ { \\varphi ^ { l o s s } } \\theta _ { t }$ , by the chain rule, $\\nabla _ { \\varphi ^ { l o s s } } \\theta _ { t } ~ = ~ \\left( \\nabla _ { G _ { t - 1 } } \\theta _ { t } \\right) \\cdot \\left( \\nabla _ { \\varphi ^ { l o s s } } G _ { t - 1 } \\right)$ . From Requirement $\\mathrm { I I }$ , it follows that $\\nabla _ { G _ { t - 1 } } \\theta _ { t }$ exists, and from Requirement IIIb, it follows that $\\nabla _ { \\varphi ^ { l o s s } } G _ { t - 1 }$ exists, therefore so does $\\nabla _ { \\varphi ^ { l o s s } } \\theta _ { t }$ . ",
+        "bbox": [
+            210,
+            633,
+            825,
+            698
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Putting these both together, and having covered the union of $\\varphi ^ { o p t }$ and $\\varphi ^ { l o s s }$ by exhaustion, we have shown that the gradients $\\nabla _ { \\varphi } \\mathcal { L } ^ { v a l } ( \\mathbf { \\bar { \\theta } } ^ { * } )$ can be obtained by composition over the gradient paths $( \\nabla _ { \\theta _ { t } } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } ) ) ( \\nabla _ { \\varphi } \\theta _ { t } )$ for all $t \\in [ 1 , T ]$ . In Section 2.5 we show how to implement the exact and efficient calculation of $\\nabla _ { \\varphi } \\mathcal { L } ^ { v a l } ( \\theta ^ { * } )$ . To complete this section, we indicate the conditions under which requirements I–III hold in practice. ",
+        "bbox": [
+            173,
+            710,
+            825,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Requirement I is simply a function of the choice of evaluation metric used to evaluate the model after training as part of $\\dot { \\mathcal { L } } ^ { v a l }$ . If this is not a differentiable function of $\\theta ^ { * }$ , e.g. BLEU (Papineni et al., 2002) in machine translation, then a proxy metric can be selected for meta-training (e.g. negative log-likelihood of held out data), or gradient estimation methods such as REINFORCE (Williams, 1992) can be used. ",
+        "bbox": [
+            176,
+            791,
+            823,
+            834
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Requirement II is a function of the choice of optimizer, but is satisfied for most popular optimizers. We directly prove that this requirement holds for SGD (Robbins & Monro, 1951) and for ADAGRAD (Duchi et al., 2011) in Appendix A, and prove it by construction for a wider class of common optimizers in the implementation and tests of the software library described in Section 4. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            195
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Requirement IIIa is a function of the choice of hyperparameters and optimizer, but is satisfied for at least the learning rate in most popular optimizers. Requirement IIIb is a function of the choice of loss function $\\ell ^ { t r a i n }$ (or class thereof), in that $\\nabla _ { \\theta _ { t } } \\ell _ { t } ^ { t r a i n } ( \\bar { \\theta _ { t } } , \\varphi ^ { l o s s } )$ needs to exist and be a differentiable function of $\\varphi$ . Usually, this requirement is held where $\\varphi$ is a multiplicative modifier of $\\theta _ { t }$ . For algorithms such as Model Agnostic Meta-Learning (Finn et al., 2017, MAML), this requirement is equivalent to saying that the Hessian of the loss function with regard to the parameters exists. ",
+        "bbox": [
+            174,
+            202,
+            825,
+            286
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.5 THE GIMLI UPDATE ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            303,
+            441,
+            316
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Algorithm 1, we present the algorithm which permits the computation of updates to metavariables through the nested iterative optimization process laid out above. To clearly disentangle different gradient paths, we employ the mathematical fiction that is the “stop-gradient” operator, which is defined as an operator which maintains the truth of the following expression: ",
+        "bbox": [
+            174,
+            328,
+            825,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/959c262df855f6e6bccdc4764b0046403e54cc31a3faf0ceeb1caab297e2a643.jpg",
+        "text": "$$\n\\begin{array} { r l r } { \\underline { { [ - ] } } } & { : } & { \\forall f \\left[ \\left( \\underline { { [ f ( x ) ] } } = f ( x ) \\right) \\wedge \\left( \\nabla _ { x } \\underline { { [ f ( x ) ] } } = 0 \\right) \\right] } \\\\ { \\mathbf { s t o p } ( x ) } & { } & \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            388,
+            689,
+            431
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As will be shown below, this will allow us to decompose the computation of updates to the metavariables through an arbitrarily complex training process, agnostic to the models and optimizers used (subject to the requirements of Section 2.4 being satisfied), into a series of local updates passing gradient with regard to the loss back through the inner loop steps. This is akin to backpropagation through time (BPTT; Rumelhart et al., 1985), a method which has been adapted to other nested optimization processes with various constraints or restrictions (Andrychowicz et al., 2016; Franceschi et al., 2017; 2018). ",
+        "bbox": [
+            173,
+            435,
+            825,
+            532
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 The GIMLI update loop ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            547,
+            419,
+            561
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Require: Current model parameters $\\theta _ { t }$ , meta-parameters $\\varphi _ { \\tau }$   \nRequire: Number of meta-parameter updates $I$ , length of unrolled inner loop $J$   \n1: for $i = 0$ to $I - 1$ do   \n2: Segment meta-parameters $\\varphi _ { i } ^ { o p t } , \\varphi _ { i } ^ { l o s s } \\gets \\mathbf { s p l i t } ( \\varphi _ { \\tau + i } )$   \n3: Copy model state ${ \\theta } _ { 0 } ^ { \\prime } \\gets { \\theta } _ { t }$ , optimizer state $\\mathbf { o p t } _ { 0 } ^ { \\prime }  \\mathbf { o p t } _ { t }$   \n4: 5: for $j = 0$ te in $J - 1$ gradodel and retain gradient graph state   \n$G _ { j } \\gets \\nabla _ { \\theta _ { j } ^ { \\prime } } \\ell _ { t + j } ^ { t r a i n } ( \\theta _ { j } ^ { \\prime } , \\varphi _ { i } ^ { l o s s } )$   \n$\\theta _ { j + 1 } ^ { \\prime }  \\mathbf { o p t } _ { j } ^ { \\prime } ( \\theta _ { j } ^ { \\prime } , \\varphi _ { i } ^ { o p t } , G _ { j } )$   \n7: end for   \n8: Initialize accumulators: $A _ { i } ^ { o p t } \\gets \\mathbf { z e r o s L i k e } ( \\varphi _ { i } ^ { o p t } ) ; A _ { i } ^ { l o s s } \\gets \\mathbf { z e r o s L i k e } ( \\varphi _ { i } ^ { l o s s } )$   \n9: Compute $B _ { J }  \\nabla _ { \\theta _ { J } ^ { \\prime } } \\mathcal { L } ^ { v a l } ( \\theta _ { J } ^ { \\prime } )$   \n10: for $j ^ { \\prime } = J - 1$ to 0 do   \n11: Compute optimizer-gradient derivative $O _ { j ^ { \\prime } } \\gets \\nabla _ { G _ { j ^ { \\prime } } } \\mathbf { o p t } _ { j ^ { \\prime } } ^ { \\prime } ( \\theta _ { j ^ { \\prime } } ^ { \\prime } , \\varphi _ { i } ^ { o p t } , G _ { j ^ { \\prime } } )$   \n12: $\\begin{array} { r l } & { \\mathrm { U p d a t e \\ } A _ { i } ^ { o p t } \\gets A _ { i } ^ { o p t } + B _ { j ^ { \\prime } + 1 } \\cdot ( \\nabla _ { \\varphi _ { i } ^ { o p t } } \\mathrm { o p t } _ { j ^ { \\prime } } ^ { \\prime } ( \\mathrm { \\small { \\texttt { [ \\theta ] } } } _ { y } ^ { \\prime } , \\mathrm { \\small { \\texttt { [ \\varphi ] } } } _ { i } ^ { \\prime , o p t } , \\mathrm { \\small { \\texttt { [ \\varphi ] } } } _ { 5 } ^ { \\prime , o p t } ) ) } \\\\ & { \\mathrm { U p d a t e \\ } A _ { i } ^ { l o s s } \\gets A _ { i } ^ { l o s s } + B _ { j ^ { \\prime } + 1 } \\cdot O _ { j ^ { \\prime } } \\cdot ( \\nabla _ { \\varphi _ { i } ^ { l o s s } } \\nabla _ { \\theta _ { j ^ { \\prime } } ^ { \\prime } } \\ell _ { t + j ^ { \\prime } } ^ { t r a i n } ( \\mathrm { \\small { \\texttt { [ \\theta ] } } } _ { y } ^ { \\prime , o p t } ) } \\\\ & { \\mathrm { C o m p u t e \\ } B _ { j ^ { \\prime } } \\gets B _ { j ^ { \\prime } + 1 } \\cdot ( ( \\nabla _ { \\theta _ { j ^ { \\prime } } } \\mathrm { o p t } _ { j ^ { \\prime } } ^ { \\prime } ( \\theta _ { j ^ { \\prime } } ^ { \\prime } , \\varphi _ { i } ^ { o p t } , \\mathrm { \\small { \\texttt { [ \\theta ] } } } _ { \\mathrm { s t o p } ( \\theta _ { j ^ { \\prime } } ) } ^ { \\prime } ) ) ) + O _ { j ^ { \\prime } } \\cdot ( \\nabla _ { \\theta _ { j ^ { \\prime } } ^ { \\prime } } ^ { 2 } \\ell _ { t + j ^ { \\prime } } ^ { t r a i n } ( \\theta _ { j ^ { \\prime } } ^ { \\prime } , \\varphi _ { i } ^ { l o s s } ) ) ) } \\\\ &  \\mathrm { c o m p u t e \\ } B _ { j ^ { \\prime } } \\gets B _ { j ^ { \\prime } + 1 } \\cdot ( ( \\nabla _ { \\theta _ { j ^ { \\prime } } } \\mathrm { o p t } _ { j ^ { \\prime } } ^ { \\prime } ( \\theta _ { j ^ { \\prime } } ^ { \\prime } , \\varphi _ { i } ^ { o p t } , \\mathrm { \\small { \\texttt { [ \\theta ] } } } _ { \\mathrm { s t o p } ( \\theta _ { j ^ { \\prime } } ) } ^ { \\prime } ) ) + O _ { j ^ { \\prime } } \\cdot ( \\nabla _ { \\theta _ { j ^ { \\prime } } ^ { \\prime } } ^ { 2 }  \\end{array}$   \n13:   \n14:   \n15: end for   \n16: Update meta-parameters $\\varphi _ { \\tau + i + 1 } \\gets \\mathbf { m e t a o p t } ( \\varphi _ { \\tau + i } , \\mathbf { j o i n } ( A _ { i } ^ { o p t } , A _ { i } ^ { l o s s } ) )$   \n17: end for   \n18: return Updated meta-parameters $\\varphi _ { \\tau + I }$ ",
+        "bbox": [
+            174,
+            564,
+            797,
+            880
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Each iteration through the loop defined by lines 1–17 does one gradient-based update of metaparameters $\\varphi$ using the optimizer employed in line 16. Each such iteration, we first (line 3) copy the model and optimizer state (generally updated through some outer loop within which this update loop sits). We then (lines 4–7) compute a series of $J$ updates on a copy of the model, preserving the intermediate gradient computations $G _ { 0 } , \\ldots , G _ { J - 1 }$ , intermediate model parameters ${ \\bar { \\theta } } _ { 0 } ^ { \\prime } , \\dots , \\bar { \\theta } _ { J } ^ { \\prime }$ (sometimes confusingly referred to as “fast weights”, following Hinton $\\&$ Plaut (1987), within the meta-learning literature), and all associated activations. These will be reused in the second stage (lines 10–15) to backpropagate higher-order gradients of the meta-loss, computed on line 9 through the optimization process that was run in lines 4–7. In particular, in lines 12 and 13, local (i.e. time step-specific) gradient calculations compute part of the gradient of $\\nabla _ { \\varphi _ { i } ^ { o p t } } \\mathcal { L } ^ { v a l } ( \\theta _ { J } ^ { \\prime } )$ and $\\nabla _ { \\varphi _ { i } ^ { l o s s } } \\mathcal { L } ^ { v a l } ( \\theta _ { J } ^ { \\prime } )$ , which is stored in accumulators which contain the exact respective gradients by the end of loop. What permits this efficient local computation is the dynamic programming calculation of the partial derivative $B _ { j ^ { \\prime } } = \\nabla _ { \\theta _ { j ^ { \\prime } } ^ { \\prime } }$ as function of only $B _ { j ^ { \\prime } + 1 }$ and timestep-specific gradients, implementing a second-order variant of BPTT through reverse-mode differentiation. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            280
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXAMPLES AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            305,
+            483,
+            320
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we highlight some instances of meta-learning which are instances of GIMLI, before discussing related approaches involving support for nested optimization, with applications to similar problems. The aim is not to provide a comprehensive literature review, which space would not permit. Rather, in pointing out similarity under our GIMLI formulation, we aim to showcase that rich and diverse research has been done using this class of approaches, where yet more progress indubitably remains to be made. This is, we believe, the strongest motivation for the development of libraries such as the one we present in Section 4 to support the implementation of algorithms that fall under the general algorithm derived in Section 2. ",
+        "bbox": [
+            174,
+            338,
+            825,
+            450
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            472,
+            290,
+            486
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Many of the papers referenced below contain excellent and thorough reviews of the literature most related to the type of meta-learning they approach. In the interest of brevity, we will not attempt such a review here, but rather focus on giving examples of a few forms of meta-learning that fit the GIMLI framework (and thus are supported by the library presented in Section 4), and briefly explain why. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "One popular meta-learning problem is that of learning to optimize hyperparameters through gradient-based methods (Bengio, 2000; Maclaurin et al., 2015; Luketina et al., 2016; Franceschi et al., 2017), as an alternative to grid/random search (Bergstra & Bengio, 2012) or Bayesian Optimization (Mockus et al., 1978; Pelikan et al., 1999; Bergstra et al., 2011; Snoek et al., 2012). Here, select continuous-valued hyperparameters are meta-optimized against a meta-objective, subject to the differentiability of the optimization step, and, where relevant, the loss function. This corresponds to Requirements $\\mathrm { I I }$ and IIIa of Section 2.4 being met, i.e. GIMLI being run with select optimizer hyperparameters as part of $\\varphi ^ { o p t }$ . To give a simple concrete example, in the approaches of Bengio (2000) and Maclaurin et al. (2015), the only meta-variable is the learning rate $\\alpha$ , i.e. $\\varphi = \\varphi ^ { o p t } = \\bar { \\alpha }$ . ",
+        "bbox": [
+            174,
+            561,
+            825,
+            688
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A related problem is that of learning the optimizer wholesale as a parametric model (Hochreiter et al., 2001; Andrychowicz et al., 2016; Duan et al., 2016), typically based on recurrent architectures. Again, here the optimizer’s own parameters are the optimizer hyperparameters, and constitute the entirety of $\\varphi ^ { o p t }$ as used within GIMLI. Requirements II and IIIa are trivially met through the precondition that such optimizers models have parameters with regard to which their output (and losses that are a function thereof) is differentiable. As a concrete example, in the work of Andrychowicz et al. (2016), an RNN with parameters $\\phi$ is meta-learned, and models the updates made to parameters during training. In our formalism, this would correspond to setting as meta-variable the parameters of this update network, i.e. $\\varphi ^ { o p t } = \\phi$ . ",
+        "bbox": [
+            173,
+            694,
+            825,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "More recently, meta-learning approaches such as MAML (Finn et al., 2017; Antoniou et al., 2018) and its variants/extensions have sought to use higher-order gradients to meta-learn model/policy initializations in few-shot learning settings. In GIMLI, this corresponds to setting $\\theta _ { 0 } = \\varphi ^ { l o s s }$ , which then is not an explicit function of $\\ell ^ { t r a i n }$ in Equation 3, but rather is implicitly its argument through updates to the inner model over the unrolled optimization. All requirements in Section 2.4 must be satisfied (save IIIa, with Requirement IIIb further entailing that $\\bar { \\ell } ^ { t r a i n }$ be defined such that the second derivative of the function with regard to $\\theta$ exists (i.e. is non-zero). ",
+        "bbox": [
+            174,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Finally, recent work by Chebotar et al. (2019) has introduced the $\\mathrm { { \\bf M L } ^ { 3 } }$ framework for learning unconstrained loss functions as parametric models, through exploiting second-order gradients of a meta-loss with regard to the parameters of the inner loss. This corresponds, in GIMLI, to learning a parametric model of the loss parameterized by $\\varphi ^ { l o s s }$ . ",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            176,
+            330,
+            190
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In a sense, many if not all of the approaches discussed in Section 3.1 qualify as “related work”, but here we will briefly discuss approaches to the general problem of formalizing and supporting implementations of problems that fit within the nested optimization specified by GIMLI. ",
+        "bbox": [
+            176,
+            202,
+            821,
+            244
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first is work by Franceschi et al. (2018) which describes how several meta-learning and hyperparameter optimization approaches can be cast as a bi-level optimization process, akin to our own formalization in 2.3. This fascinating and relevant work is highly complementary to the formalization and discussion presented in our paper. Whereas we focus on the requirements according to which gradient-based solutions to approaches based on nested optimization problems can be found in order to drive the development of a library which permits such approaches to be easily and scalably implemented, their work focuses on analysis of the conditions under which exact gradient-based solutions to bi-level optimization processes can be approximated, and what convergence guarantees exist for such guarantees. In this sense, this is more relevant to those who wish to analyze and extend alternatives to first-order approximations of algorithms such as MAML, e.g. see work of Nichol & Schulman (2018) or Rajeswaran et al. (2019). ",
+        "bbox": [
+            174,
+            251,
+            825,
+            404
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the software front, the library learn2learn (Arnold et al., 2019) addresses similar problems to that which we will present in Section 4. This library focuses primarily on providing implementations of existing meta-learning algorithms and their training loops that can be extended with new models. In contrast, the library we present in Section 4 is “closer to the metal”, aiming to support the development of new meta-learning algorithms fitting the GIMLI definitions with as little resort to non-canonical PyTorch as possible. A recent parallel effort, Torchmeta (Deleu et al., 2019) also provides a library aiming to assist the implementation of meta-learning algorithms, supplying useful data-loaders for meta-training. However, unlike our approach described in 4, it requires re-implementation of models using their functional/stateless building blocks, and for users to reimplement the optimizers in a differentiable manner. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            550
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 THE unnamedlib LIBRARY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            570,
+            441,
+            587
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section, we provide a high-level description of the design and capabilities of unnamedlib,4 a PyTorch (Paszke et al., 2017) library aimed at enabling implementations of GIMLI with as little reliance on non-vanilla PyTorch as possible. In this section, we first discuss the obstacles that would prevent us from implementing this in popular deep learning frameworks, how we overcame these in PyTorch to implement GIMLI. Additional features, helper functions, and other considerations when using/extending the library are provided in its documentation. ",
+        "bbox": [
+            174,
+            602,
+            825,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 OBSTACLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            702,
+            297,
+            717
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many deep learning frameworks offer the technical functionality required to implement GIMLI, namely the ability to take gradients of gradients. However, there are two aspects of how we implement and train parametric models in such frameworks which inhibit our ability to flexibly implement Algorithm 1. ",
+        "bbox": [
+            174,
+            728,
+            823,
+            784
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first obstacle is that models are typically implemented statefully (e.g. torch.nn in PyTorch, keras.layers in Keras (Chollet et al., 2015), etc.), meaning that the model’s parameters are encapsulated in the model implementation, and are implicitly relied upon during the forward pass. Therefore while such models can be considered as functions theoretically, they are not pure functions practically, as their output is not uniquely determined by their explicit input, and equivalently the parameters for a particular forward pass typically cannot be trivially overridden or supplied at call time. This prevents us from tracking and backpropagating over the successive values of the model parameters $\\theta$ within the inner loop described by Equation 3, through an implicit or explicit graph. ",
+        "bbox": [
+            174,
+            791,
+            825,
+            876
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The second issue is that, as discussed at the end of Section 2.4 and in Appendix A, even though the operations used within popular optimizers are mathematically differentiable functions of the parameters, gradients, and select hyperparameters, these operations are not tracked in various framework’s implicit or explicit graph/gradient tape implementations when an optimization step is run. This is with good reason: updating model parameters in-place is memory efficient, as typically there is no need to keep references to the previous version of parameters. Ignoring the gradient dependency formed by allowing backpropagation through an optimization step essentially makes it safe to release memory allocated to historical parameters and intermediate model states once an update has been completed. Together, these obstacles essentially prevent us from practically satisfying Requirement II of Section 2.4. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 MAKING STATEFUL MODULES STATELESS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            297,
+            501,
+            310
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "As we wish to track and backpropagate through intermediate states of parameters during the inner loop, we keep a record of such states which can be referenced during the backward pass stage of the outer loop in Algorithm 1. The typical way this is done in implementations of meta-learning algorithms such as MAML is to rewrite a “stateless” version of the inner loop’s model, permitting the use, in each invocation of the model’s forward pass, of weights which are otherwise tracked on the gradient graph/tape. While this addresses the issue, it is an onerous and limiting solution, as exploring new models within such algorithms invariably requires their reimplementation in a stateless style. This typically prevents the researcher from experimenting with third-party codebases, complicated models, or those which requiring loading pre-trained weights, without addressing a significant and unwelcome engineering challenge. ",
+        "bbox": [
+            174,
+            323,
+            825,
+            462
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "A more generic solution, permitting the use of existing stateful modules (including with pre-loaded activations), agnostic to the complexity or origin of the code which defines them, is to modify the run-time instance of the model’s parent class to render them effectively function, a technique often referred to as “monkey-patching”. The high-level function unnamedlib.monkeypatch() does this by taking as argument a torch.nn.Module instance and the structure of its nested sub-modules. As it traverses this structure, it clones the parent classes of submodule instances, leaving their functionality intact save for that of the forward method which implements the forward pass. Here, it replaces the call to the forward method with one which first replaces the stateful parameters of the submodule with ones provided as additional arguments to the patched forward, before calling the original class’s bound forward method, which will now used the parameters provided at call time. This method is generic and derived from first-principles analysis of the torch.nn.Module implementation, ensuring that any first or third-party implementation of parametric models which are subclasses of torch.nn.Module and do not abuse the parent class at runtime will be supported by this recursive patching process. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            662
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.3 MAKING OPTIMIZERS DIFFERENTIABLE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            681,
+            486,
+            695
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Again, as part of our need to make the optimization process differentiable in order to satisfy Requirement II of Section 2.4, the typical solution is to write a version of SGD which does not modify parameters in-place, but treated as a differentiable function of the input parameters and hyperparameters akin to any other module in the training process. While this, again, is often considered a satisfactory solution in the meta-learning literature due to its simplicity, it too is limiting. Not only does the inability to experiment with other inner loop optimizers prevent research into the applicability of meta-learning algorithms to other optimization processes, the restriction to SGD also means that existing state-of-the-art methods used in practical domains cannot be extended using meta-learning methods such as those described in Section 3, lest they perform competitively when trained with SGD. ",
+        "bbox": [
+            174,
+            708,
+            823,
+            847
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Here, while less generic, the solution provided by the high-level function unnamedlib.get diff optim() is to render a PyTorch optimizer instance differentiable by mapping its parent class to a differentiable reimplementation of the instance’s parent class. The reimplementation is typically a copy of the optimizer’s step logic, with in-place operations being replaced with gradient-tracking ones (a process which is syntactically simple to execute in PyTorch). ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To this, we add wrapper code which copies the optimizer’s state, and allows safe branching off of it, to permit “unrolling” of the optimization process within an inner loop (cf. the recurrence from Equation 3) without modifying the initial state of the optimizer (e.g. to permit several such unrolls, or to preserve state if inner loop optimizer is used elsewhere in the outer loop). Most of the optimizers in torch.optim are covered by this method. Here too, a runtime modification of the parent optimizer class could possibly be employed as was done for torch.nn.Modules, but this would involve modifying Python objects at a far finer level of granularity. We find that supporting a wide and varied class of optimizers is a sufficient compromise to enable further research.5 ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            234,
+            326,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this section, we briefly present some results of experiments using select existing methods from Section 3.1, to show case how unnamedlib can be used to simply implement ablation studies and searches over model architectures, optimizers, and other aspects of an experiment. This could, naturally, be done without appeal to the library. However, in such cases, changing the model architecture or optimizer requires re-implementing the model functionally or optimization step differentiably. Here such changes require writing no new code (excluding the line where the model is defined). ",
+        "bbox": [
+            174,
+            267,
+            825,
+            349
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.1 META-LEARNING LEARNING RATES WITH HIGHER GRANULARITY ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            368,
+            665,
+            382
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As the first application for unnamedlib, we set up a simple meta-learning task where we metaoptimize the learning rate. Employing a handcrafted annealing schedule for learning rates has been the de facto approach to improving a learning algorithm. While scheduled annealing can help to boost the final performance, it usually requires significant hand-tuning of the schedule. In contrast, we adjust learning rates automatically using meta-learning, which unnamedlib enables for arbitary models and optimizers. ",
+        "bbox": [
+            174,
+            393,
+            825,
+            477
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We take an image classification model DenseNet-BC( $k { = } 1 2$ ) (Huang et al., 2016), that provides competitive state-of-the-art results on CIFAR10, and modify its training procedure by replacing the multi-step annealing schedule of learning rate with a meta-optimizer. Specifically, we treat learning rate for each inner optimizer’s parameter group as a separate meta-parameter that we will metalearn. Doing so allows individual model parameters to have finer learning rates, that are adjusted automatically. The GIMLI algorithm provides for a clean implementation of such training procedure. ",
+        "bbox": [
+            174,
+            484,
+            825,
+            568
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/df66c86a540cfae9842eb6d58d4b2ec1d50959f2875bfcb3a27a357c3d3744de.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of meta-learned learning rates against fixed and multi-step annealed for training DenseNet-BC( $_ { \\mathrm { k = } 1 2 }$ ) on CIFAR10. We observe convergence near state-of-the-art with better sample complexity that using a hand-designed annealing schedule. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            584,
+            818,
+            715
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We first train two baseline variants of DenseNet-BC( $\\mathtt { k } = \\mathtt { l } 2$ ) using setup from (Huang et al., 2016). In the first variant we keep the learning rate fixed to 0.1 for all 300 epochs, while the second configuration takes advantage of a manually designed multi-step annealing schedule, which drops learning rate by 10 after 150 and 225 epochs. For the meta-learning variant, we split the training set into two disjoint pieces, one for training and another for validation, in proportion of $9 9 : 1$ . We then use per parameter group learning rates (299 in total) for meta-optimization, initializing each learning rate to 0.1. We perform one meta-update step after each epoch, where we unroll inner optimizer for ",
+        "bbox": [
+            174,
+            790,
+            825,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/b47ab38d000d7a0cd2d044c4e005440a5e01c19821460ef470ff1310765232c9.jpg",
+        "table_caption": [
+            "Table 1: Results from ablating $\\mathbf { M A M L + + }$ architecture and inner optimizers. “Our base” results are from our VGG model trained with SGD in our $\\mathbf { M A M L + }$ variant, and “our best” results show the best test accuracy found, with the best model/optimizer combination shown in the text below. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\"></td><td colspan=\"4\">omniglot test accuracy</td><td colspan=\"2\">miniImageNet test accuracy</td></tr><tr><td>5Way</td><td></td><td>20Way</td><td></td><td>5Way</td><td></td></tr><tr><td>Approach</td><td>1 Shot</td><td>5 Shot</td><td>1 Shot</td><td>5 Shot</td><td>1 Shot</td><td>5 Shot</td></tr><tr><td>MAML++ (Antoniou et al., 2018)</td><td>99.53 ± 0.26%</td><td>99.93 ± 0.09%</td><td>97.65 ± 0.05%</td><td>99.33±0.03%</td><td>52.15± 0.26%</td><td>68.32±0.44</td></tr><tr><td>MAML++ (Our base)</td><td>99.62 ± 0.08%</td><td>99.86 ± 0.02%</td><td>97.21 ± 0.11%</td><td>99.13 ±0.13%</td><td>56.33 ± 0.27%</td><td>75.13 ± 0.67%</td></tr><tr><td>MAML++ (Our best)</td><td>99.91 ± 0.05%</td><td>99.87 ± 0.03%</td><td>99.00 ± 0.33%</td><td>99.76 ± 0.01%</td><td>56.33 ± 0.27%</td><td>76.73 ± 0.52%</td></tr><tr><td></td><td>resnet-4+SGD</td><td>resnet-4+SGD</td><td>resnet-12+SGD</td><td>resnet-8+SGD</td><td>vgg+SGD</td><td>resnet-8+SGD</td></tr></table>",
+        "bbox": [
+            173,
+            154,
+            823,
+            226
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "15 steps using batches from the training set, and compute meta-test error on the validation set over 10 batches from the validation set. We use batch size of 16 for meta-update, rather than 64 as in the base training loop. We use Adam (Kingma & Ba, 2014) with default parameters as a choice for meta-optimizer. We average results over 3 random seeds. Figure 1 demonstrates that our method is able reach the state-of-the-art performance faster. ",
+        "bbox": [
+            174,
+            251,
+            825,
+            320
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5.2 ABLATING MAML’S MODEL ARCHITECTURE AND INNER OPTIMIZER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            338,
+            689,
+            352
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The unnamedlib library enables the exploration of new MAML-like models and inner-loop optimizers, which historically has required non-trivial implementations of the fast-weights for the model parameters and inner optimizers as done in Antoniou et al. (2018); Deleu et al. (2019). These ablations can be important for squeezing the last few bits of accuracy on well-established tasks and baselines that are already near-optimal as shown in Chen et al. (2019), and is even more important for developing new approaches and tasks that deal with different kinds of data and require adaptation to be done over non-standard operations. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            462
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To illustrate how easy unnamedlib makes these ablations, in this section we take a closer look at different model architecture and optimizer choices for the $\\mathbf { M A M L + + }$ approach (Antoniou et al., 2018). MAML $^ { + + }$ uses a VGG network with a SGD inner optimizer for the the Omniglot (Lake et al., 2015) and Mini-Imagenet (Vinyals et al., 2016; Ravi & Larochelle, 2016) tasks. We start with the official $\\mathbf { M A M L + + }$ code and evaluation procedure and use unnamedlib to ablate across VGG, ResNet, and DenseNet models and SGD and Adam optimizers. We provide more details about these in Appendix B. We denote the combination of model and inner optimizer choice with $< \\mathrm { m o d e l } > + < \\mathrm { o p t } >$ . One finding of standalone interest is that we have kept most of the features from $\\mathbf { M A M L + }$ , except we significantly increase the base $\\mathtt { V G G + S G D }$ performance by using batch normalization in training mode everywhere as in (Finn et al., 2017) instead of using per-timestep statistics and parameters as $\\mathbf { M A M L + }$ proposes. In theory, this enables more inner optimization steps to be rolled out at test time, which otherwise is not possible with $\\mathbf { M A M L + } +$ because of the pertimestep information, for simplicity in this paper we have not explored this and keep every algorithm, optimizer, and mode to five inner optimization steps. When using Adam as the inner optimizer, we initialize the first and second moment statistics to the statistics from the outer optimizer, which is also Adam, and learn per-parameter-group learning rates and rolling average $\\beta$ coefficients. Our results in Table 1 show that we are able to push the accuracy of $\\mathbf { M A M L + + }$ slightly up with this ablation. We note that this pushes the performance of $\\mathbf { M A M L + } +$ closer to that of state-of-the-art methods such as LEO (Rusu et al., 2018). Appendix B shows our full experimental results, and we note that in some cases Adam slightly outperforms SGD for a particular model. ",
+        "bbox": [
+            174,
+            468,
+            825,
+            746
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            767,
+            318,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "To summarize, we have presented GIMLI, a general formulation of a wide class of existing and potential meta-learning approaches, listed and proved the requirements that must be satisfied for such approaches to be possible, and specified a general algorithmic formulation of such approaches. We’ve described a lightweight library, unnamedlib, which extends PyTorch to enable the easy and natural implementation of such meta-learning approaches at scale. Finally we’ve demonstrated some of its potential applications. We hope to have made the case not only for the use of the mathematical and software tools we present here, but have also provided suitable encouragement for other researchers to use them and explore the boundaries of what can be done within this broad class of meta-learning approaches. ",
+        "bbox": [
+            174,
+            799,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W Hoffman, David Pfau, Tom Schaul, Brendan Shillingford, and Nando De Freitas. Learning to learn by gradient descent by gradient descent. In Advances in neural information processing systems, pp. 3981–3989, 2016. ",
+        "bbox": [
+            176,
+            126,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Antreas Antoniou, Harrison Edwards, and Amos Storkey. How to train your maml. arXiv preprint arXiv:1810.09502, 2018. ",
+        "bbox": [
+            171,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Seb Arnold, Praateek Mahajan, Debajyoti Datta, and Ian Bunner. learn2learn. ´ https:// github.com/learnables/learn2learn, 2019. ",
+        "bbox": [
+            171,
+            218,
+            823,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio. Gradient-based optimization of hyperparameters. Neural computation, 12(8):1889– 1900, 2000. ",
+        "bbox": [
+            173,
+            256,
+            823,
+            285
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012. ",
+        "bbox": [
+            173,
+            295,
+            823,
+            324
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. In Advances in neural information processing systems, pp. 2546–2554, 2011. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yevgen Chebotar, Artem Molchanov, Sarah Bechtle, Ludovic Righetti, Franziska Meier, and Gaurav Sukhatme. Meta-learning via learned loss. arXiv preprint arXiv:1906.05374, 2019. ",
+        "bbox": [
+            174,
+            372,
+            823,
+            402
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification, 2019. ",
+        "bbox": [
+            173,
+            411,
+            823,
+            440
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Franc¸ois Chollet et al. Keras, 2015. ",
+        "bbox": [
+            174,
+            450,
+            406,
+            465
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tristan Deleu, Tobias Wurfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio. Torch- ¨ meta: A Meta-Learning library for PyTorch, 2019. URL https://arxiv.org/abs/1909. 06576. Available at: https://github.com/tristandeleu/pytorch-meta. ",
+        "bbox": [
+            176,
+            476,
+            820,
+            520
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yan Duan, John Schulman, Xi Chen, Peter L Bartlett, Ilya Sutskever, and Pieter Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016. ",
+        "bbox": [
+            173,
+            529,
+            823,
+            558
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "John Duchi, Elad Hazan, and Yoram Singer. Adaptive subgradient methods for online learning and stochastic optimization. Journal of Machine Learning Research, 12(Jul):2121–2159, 2011. ",
+        "bbox": [
+            171,
+            566,
+            825,
+            597
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine LearningVolume 70, pp. 1126–1135. JMLR. org, 2017. ",
+        "bbox": [
+            176,
+            606,
+            823,
+            650
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luca Franceschi, Michele Donini, Paolo Frasconi, and Massimiliano Pontil. Forward and reverse gradient-based hyperparameter optimization. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1165–1173. JMLR. org, 2017. ",
+        "bbox": [
+            173,
+            659,
+            823,
+            703
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Luca Franceschi, Paolo Frasconi, Saverio Salzo, Riccardo Grazzi, and Massimilano Pontil. Bilevel programming for hyperparameter optimization and meta-learning. arXiv preprint arXiv:1806.04910, 2018. ",
+        "bbox": [
+            173,
+            712,
+            825,
+            755
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            173,
+            763,
+            821,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey E Hinton and David C Plaut. Using fast weights to deblur old memories. In Proceedings of the ninth annual conference of the Cognitive Science Society, pp. 177–186, 1987. ",
+        "bbox": [
+            171,
+            816,
+            823,
+            847
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter, A Steven Younger, and Peter R Conwell. Learning to learn using gradient descent. In International Conference on Artificial Neural Networks, pp. 87–94. Springer, 2001. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. CoRR, 2016. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            173,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Diederik P Kingma and Max Welling. Auto-encoding variational bayes. arXiv preprint arXiv:1312.6114, 2013. ",
+        "bbox": [
+            174,
+            193,
+            825,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Brenden M Lake, Ruslan Salakhutdinov, and Joshua B Tenenbaum. Human-level concept learning through probabilistic program induction. Science, 350(6266):1332–1338, 2015. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jelena Luketina, Mathias Berglund, Klaus Greff, and Tapani Raiko. Scalable gradient-based tuning of continuous regularization hyperparameters. In International conference on machine learning, pp. 2952–2960, 2016. ",
+        "bbox": [
+            173,
+            267,
+            823,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dougal Maclaurin, David Duvenaud, and Ryan Adams. Gradient-based hyperparameter optimization through reversible learning. In International Conference on Machine Learning, pp. 2113– 2122, 2015. ",
+        "bbox": [
+            173,
+            319,
+            826,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jonas Mockus, Vytautas Tiesis, and Antanas Zilinskas. The application of bayesian methods for seeking the extremum. Towards global optimization, 2(117-129):2, 1978. ",
+        "bbox": [
+            171,
+            371,
+            821,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Alex Nichol and John Schulman. Reptile: a scalable metalearning algorithm. arXiv preprint arXiv:1803.02999, 2, 2018. ",
+        "bbox": [
+            171,
+            409,
+            823,
+            439
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Boris Oreshkin, Pau Rodr´ıguez Lopez, and Alexandre Lacoste. Tadam: Task dependent adaptive ´ metric for improved few-shot learning. In Advances in Neural Information Processing Systems, pp. 721–731, 2018. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            489
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Kishore Papineni, Salim Roukos, Todd Ward, and Wei-Jing Zhu. Bleu: a method for automatic evaluation of machine translation. In Proceedings of the 40th annual meeting on association for computational linguistics, pp. 311–318. Association for Computational Linguistics, 2002. ",
+        "bbox": [
+            173,
+            498,
+            826,
+            542
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "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 NIPS Autodiff Workshop, 2017. ",
+        "bbox": [
+            178,
+            550,
+            823,
+            594
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Martin Pelikan, David E Goldberg, and Erick Cantu-Paz. Boa: The bayesian optimization algorithm. ´ In Proceedings of the 1st Annual Conference on Genetic and Evolutionary Computation-Volume 1, pp. 525–532. Morgan Kaufmann Publishers Inc., 1999. ",
+        "bbox": [
+            176,
+            602,
+            823,
+            645
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aravind Rajeswaran, Chelsea Finn, Sham Kakade, and Sergey Levine. Meta-learning with implicit gradients. arXiv preprint arXiv:1909.04630, 2019. ",
+        "bbox": [
+            173,
+            654,
+            823,
+            683
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. CoRR, 2016. ",
+        "bbox": [
+            171,
+            691,
+            803,
+            708
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Herbert Robbins and Sutton Monro. A stochastic approximation method. The annals of mathematical statistics, pp. 400–407, 1951. ",
+        "bbox": [
+            171,
+            715,
+            823,
+            746
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "David E Rumelhart, Geoffrey E Hinton, and Ronald J Williams. Learning internal representations by error propagation. Technical report, California Univ San Diego La Jolla Inst for Cognitive Science, 1985. ",
+        "bbox": [
+            174,
+            753,
+            823,
+            796
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Andrei A Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. Meta-learning with latent embedding optimization. arXiv preprint arXiv:1807.05960, 2018. ",
+        "bbox": [
+            173,
+            805,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. ¨ Evolutionary principles in self-referential learning, or on learning how to learn: the meta-meta-... hook. PhD thesis, Technische Universitat M¨ unchen, 1987. ¨ ",
+        "bbox": [
+            173,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            174,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. In Advances in neural information processing systems, pp. 2951–2959, 2012. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, pp. 3630–3638, 2016. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine learning, 8(3-4):229–256, 1992. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            208
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A OPTIMIZER DIFFERENTIABILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            480,
+            119
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.1 SGD ",
+        "bbox": [
+            173,
+            132,
+            256,
+            148
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "$\\nabla _ { \\varphi } \\theta _ { t + 1 } = \\nabla _ { \\varphi } \\mathbf { S } \\mathbf { G } \\mathbf { D } ( \\theta _ { t } , G _ { t } ) = \\nabla _ { \\varphi } [ \\theta _ { t } - \\alpha G _ { t } ] = \\nabla _ { \\varphi } \\theta _ { t } - G _ { t } \\nabla _ { \\varphi } \\alpha - \\alpha \\nabla _ { \\varphi } G _ { t }$ where $\\alpha$ is the learning rate, and $\\nabla _ { \\varphi } \\alpha$ is defined iff $\\alpha \\subseteq \\varphi$ else $G _ { t } \\nabla _ { \\varphi } \\alpha = 0$ ",
+        "bbox": [
+            187,
+            166,
+            705,
+            202
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e413e30233605a3a41a220420a3d1d05ccc5cc1bc7ebff5f0b345b680f692e79.jpg",
+        "text": "$$\n\\nabla _ { \\theta _ { t } } \\theta _ { t + 1 } = \\nabla _ { \\theta _ { t } } \\mathbf { S } \\mathbf { G } \\mathbf { D } ( \\theta _ { t } , G _ { t } ) = \\nabla _ { \\theta _ { t } } [ \\theta _ { t } - \\alpha G _ { t } ] = \\nabla _ { \\theta _ { t } } \\theta _ { t } - \\alpha \\nabla _ { \\theta _ { t } } G _ { t } = 1 - \\alpha \\nabla _ { \\theta _ { t } } ^ { 2 } \\ell _ { t } ^ { t r a i n } ( \\theta _ { t } , \\varphi )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            187,
+            222,
+            810,
+            241
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.2 ADAGRAD ",
+        "bbox": [
+            173,
+            273,
+            292,
+            289
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/542cfd0407bcc97ea68a83a133984c8e0fafc469cc561aa7fd5ad9b1e5ac798b.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\nabla _ { \\varphi } \\theta _ { t + 1 } = \\nabla _ { \\varphi } \\mathbf { A } \\mathbf { d a g r a d } ( \\theta _ { t } , G _ { t } ) = \\nabla _ { \\varphi } [ \\theta _ { t } - \\frac { \\eta } { \\sqrt { \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } G _ { t } ] } \\\\ & { \\qquad = \\nabla _ { \\varphi } \\theta _ { t } - \\frac { \\eta \\nabla _ { \\varphi } G _ { t } } { \\sqrt { \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } - \\frac { G _ { t } \\nabla _ { \\varphi } \\eta } { \\sqrt { \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } + \\frac { \\eta G _ { t } \\sum _ { i = 1 } ^ { t } G _ { i } \\nabla _ { \\varphi } G _ { i } } { \\left( \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } \\right) ^ { \\frac { 3 } { 2 } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            304,
+            663,
+            397
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "where $\\eta$ is the global learning rate, and $\\nabla _ { \\varphi } \\eta$ is defined iff $\\eta \\subseteq \\varphi$ else $\\frac { \\mathrm { \\Delta } G _ { t } \\nabla _ { \\varphi } \\eta } { \\sqrt { \\sum _ { i = 1 } ^ { t } { G _ { i } ^ { 2 } } } } = 0$ ",
+        "bbox": [
+            241,
+            396,
+            812,
+            439
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c4f394438cd090fd4a7d96ade18dc01083345c0a412233683fbfe15c894faec8.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { \\nabla _ { \\theta _ { t } } \\theta _ { t + 1 } = \\nabla _ { \\theta _ { t } } \\mathbf { A } \\mathbf { d a } \\mathbf { g r a d } ( \\theta _ { t } , G _ { t } ) = \\nabla _ { \\theta _ { t } } [ \\theta _ { t } - \\frac { \\eta } { \\sqrt { \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } G _ { i } ] } & \\\\ & { } & { \\qquad = \\nabla _ { \\theta _ { t } } \\theta _ { t } - \\frac { \\eta \\nabla _ { \\theta _ { t } } G _ { t } } { \\sqrt { \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } + \\frac { \\eta G _ { t } ^ { 2 } \\nabla _ { \\theta _ { t } } G _ { t } } { \\left( \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } \\right) ^ { \\frac { 3 } { 2 } } } } \\\\ & { } & { \\qquad = 1 - \\frac { \\eta \\nabla _ { \\theta _ { t } } ^ { 2 } \\ell _ { t } ^ { t r a i n } \\left( \\theta _ { t } , \\varphi \\right) } { \\sqrt { \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } } } + \\frac { \\eta G _ { t } ^ { 2 } \\nabla _ { \\theta _ { t } } ^ { 2 } \\ell _ { t } ^ { t r a i n } \\left( \\theta _ { t } , \\varphi \\right) } { \\left( \\sum _ { i = 1 } ^ { t } G _ { i } ^ { 2 } \\right) ^ { \\frac { 3 } { 2 } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            186,
+            458,
+            607,
+            601
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B MAML $^ { + + }$ EXPERIMENTS: ADDITIONAL INFORMATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            666,
+            117
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table 2 shows all of the architectures and optimizers we ablated. The table is missing some rows as we only report the results that successfully completed running three seeds within three days on our cluster. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            175
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We use the following model architectures, which closely resemble the vanilla PyTorch examples for these architectures but are modified to be smaller for the few-shot classification setting: ",
+        "bbox": [
+            173,
+            183,
+            823,
+            210
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "• vgg is the VGG architecture (Simonyan & Zisserman, 2014) variant used in MAML $^ { + + }$ (Antoniou et al., 2018)   \n• resnet $- \\mathbb { N }$ is the ResNet architecture (He et al., 2016). resnet-4 corresponds to the four blocks having just a single layer, and resnet-8 and resnet-12 have respectively 2 and 3 layers in each block   \n• densenet-8 is the DenseNet architecture (Huang et al., 2017) with 2 layers in each block ",
+        "bbox": [
+            217,
+            222,
+            825,
+            318
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We follow TADAM (Oreshkin et al., 2018) and do not use the initial convolutional projection layer common in the full-size variants of the ResNet and DenseNet. ",
+        "bbox": [
+            173,
+            329,
+            823,
+            357
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We can also visualize how the learning rates and rolling momentum terms (with Adam) change over time when they are being learned. We show this in Figure 2 and Figure 3 for the 20-way 1-shot Omniglot experiment with the resnet-4 architecture, which is especially interesting as Adam outperforms SGD in this case. We find that most of the SGD learning rates are decreased to near-zero except for a few select few that seem especially important for the adaptation. Adam exhibits similar behavior with the learning rates where most except for a select for are zeroed for the adaptation, and the rolling moment coefficients are particularly interesting where the first moment coefficient $\\beta _ { 1 }$ becomes relatively evenly spread throughout the space while $\\beta _ { 2 }$ splits many parameter groups between low and high regions of the space. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            489
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/186e233904a586852854249f024341822523a8290a486a2496cc83cd6bb75ae5.jpg",
+        "table_caption": [
+            "Table 2: Full MAML $^ { + + }$ model and inner optimizer sweep search results. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"5\"></td><td rowspan=\"2\">mean acc</td><td rowspan=\"2\">std</td></tr><tr><td>dataset</td><td>nway</td><td>kshot</td><td>model</td><td>inner_optim</td></tr><tr><td>mini_imagenet_full_size</td><td>5</td><td>1</td><td>densenet-8</td><td>SGD</td><td>46.08</td><td>1.40</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>51.06</td><td>1.51</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>Adam</td><td>49.71</td><td>3.71</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>54.36</td><td>0.23</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>54.16</td><td>1.35</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>47.93</td><td>11.64</td></tr><tr><td></td><td></td><td>5</td><td>densenet-8</td><td>SGD</td><td>56.33</td><td>0.27</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>65.29</td><td>0.98</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>37.40</td><td>3.64</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>SGD</td><td>69.14</td><td>3.19</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>76.33</td><td>0.71</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>74.48</td><td>0.77</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>68.03</td><td>15.19</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>76.73</td><td>0.52</td></tr><tr><td>omniglot_dataset</td><td></td><td></td><td>vgg</td><td>Adam SGD</td><td>72.82</td><td>2.36</td></tr><tr><td></td><td>5</td><td>1</td><td>densenet-8</td><td>SGD</td><td>75.13</td><td>0.67</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>SGD</td><td>99.54</td><td>0.33</td></tr><tr><td></td><td></td><td></td><td></td><td>Adam</td><td>99.91</td><td>0.05</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>SGD</td><td>99.62</td><td>0.08</td></tr><tr><td></td><td></td><td>5</td><td>densenet-8</td><td>SGD</td><td>99.62</td><td>0.08</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td>99.86</td><td>0.05</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>SGD</td><td>99.87</td><td>0.03</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>99.86</td><td>0.04</td></tr><tr><td></td><td>20</td><td>1</td><td></td><td>SGD</td><td>99.86</td><td>0.02</td></tr><tr><td></td><td></td><td></td><td>densenet-8</td><td>SGD</td><td>93.20</td><td>0.32</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>99.00</td><td>0.33</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>Adam</td><td>98.31</td><td>0.09</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>96.31</td><td>0.15</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>98.50</td><td>0.15</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>96.15</td><td>0.16</td></tr><tr><td></td><td></td><td>5</td><td></td><td>SGD</td><td>97.21</td><td>0.11</td></tr><tr><td></td><td></td><td></td><td>densenet-8</td><td>SGD</td><td>97.24</td><td>0.26</td></tr><tr><td></td><td></td><td></td><td>resnet-12</td><td>SGD</td><td>99.69</td><td>0.17</td></tr><tr><td></td><td></td><td></td><td>resnet-4</td><td>Adam</td><td>99.44</td><td>0.23</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>99.71</td><td>0.03</td></tr><tr><td></td><td></td><td></td><td>resnet-8</td><td>SGD</td><td>99.76</td><td>0.01</td></tr><tr><td></td><td></td><td></td><td>vgg</td><td>Adam</td><td>98.74</td><td>0.04</td></tr><tr><td></td><td></td><td></td><td></td><td>SGD</td><td>99.13</td><td>0.13</td></tr></table>",
+        "bbox": [
+            197,
+            125,
+            803,
+            700
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/6573403018cf03c30c15107e58dd5e9277846f53a29dc9c40681bc98921a5eb0.jpg",
+        "image_caption": [
+            "Figure 2: The learning rates during a training run of a VGG network with SGD as the inner optimizer for 20-way 1-shot mini-imagenet classification. The colors show the parameter groups within the model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            339,
+            106,
+            655,
+            262
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/413e8d783bc7dd1584876aef0fb4e6d9909db56605bed7206b3da8d374e6130e.jpg",
+        "image_caption": [
+            "Figure 3: The learning rates during a training run of a VGG network with Adam as the inner optimizer for 20-way 1-shot mini-imagenet classification. The colors show the parameter groups within the model. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            348,
+            813,
+            674
+        ],
+        "page_idx": 16
+    }
+]

parse/train/Bys_NzbC-/Bys_NzbC-.md

@@ -0,0 +1,242 @@
+# ACHIEVING STRONG REGULARIZATION FOR DEEP NEURAL NETWORKS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+L1 and L2 regularizers are critical tools in machine learning due to their ability to simplify solutions. However, imposing strong L1 or L2 regularization with gradient descent method easily fails, and this limits the generalization ability of the underlying neural networks. To understand this phenomenon, we investigate how and why learning fails for strong regularization. Specifically, we examine how gradients change over time for different regularization strength and provide an analysis why the gradients diminish so fast when strong regularization is imposed. We find that there exists a tolerance level of regularization strength, where the learning completely fails if the regularization strength goes beyond it. We propose a simple but novel method, Delayed Strong Regularization, in order to moderate the tolerance level. Experiment results show that our proposed approach indeed achieves strong regularization for both L1 and L2 regularizers and improves both accuracy and sparsity on public data sets. Our source code is published.1
+
+# 1 INTRODUCTION
+
+Regularization has been very common for machine learning to prevent over-fitting and to obtain sparse solutions. Deep neural networks (DNNs), which have shown huge success in many tasks such as computer vision (Krizhevsky et al., 2012; Simonyan & Zisserman, 2014; He et al., 2016) and speech recognition (Hinton et al., 2012), often contain a number of parameters in multiple layers with non-linear activation functions, in order to gain enough expressive power. However, DNNs with many parameters are often prone to over-fitting, so the need for regularization has been emphasized. While new regularization techniques such as dropout (Srivastava et al., 2014) and pruning (Han et al., 2015) have been proposed to solve the problem, the traditional regularization techniques using L1 or L2 norms have cooperated with them to further improve the performance significantly. L1 regularization, often called Lasso (Tibshirani, 1996), obtains sparse solutions so that the required memory and power consumption are reduced while keeping reasonable accuracy. On the other hand, L2 regularization smooths the parameter distribution and reduces the magnitude of parameters, so the resulting solution is simple (i.e., less prone to over-fitting) and effective. Indeed, our empirical results show that applying strong L2 regularization to the deep neural networks that already has dropout layers can reduce the error rate by up to $24 \%$ on a public data set.
+
+Strong regularization is especially desired when the model contains too many parameters for the given amount of training data. This is often the case for deep learning tasks in practice because DNNs often contain millions of parameters while labeled training data set is limited and expensive. However, imposing strong L1 or L2 regularization on DNNs is difficult for gradient descent method due to the vanishing gradient problem. If we impose too strong regularization, the gradient from regularization becomes dominant, and DNNs stop learning. In this paper, we first study the interesting phenomenon that strong regularization fails in learning. We also provide an analysis why the gradients diminish so quickly that learning completely fails. Then, we propose a simple yet effective solution, Delayed Strong Regularization, which carries a time-dependent schedule of regularization strength. We find that we can overcome the failure in learning by waiting for the model to reach an “active learning” phase, where the gradients’ magnitudes are significant, and then enforcing strong regularization. Delayed Strong Regularization enables us to obtain the superior performance that is otherwise hidden by learning failure in deep networks. The proposed approach is general and does not require any additional computation. The experiment results indicate that the proposed approach indeed achieves strong regularization, consistently yielding even higher accuracy and higher compression rate that could not be achieved.
+
+# 2 PROBLEM ANALYSIS
+
+# 2.1 BACKGROUND
+
+Let us denote a generic DNN by $\mathbf { y } = f ( \mathbf { x } ; \mathbf { w } )$ where $\mathbf { x } \in \mathbb { R } ^ { d }$ is an input vector, $\mathbf { w } \in \mathbb { R } ^ { n }$ is a flattened vector of all parameters in the network $f$ , and $\mathbf { y } \in \mathbb { R } ^ { c }$ is an output vector after feed-forwarding $\mathbf { x }$ through multiple layers in $f$ . The network $f$ is trained by finding optimal set of w by minimizing the cost function within the training data $\{ \mathbf { x } _ { i } , \mathbf { d } _ { i } \} _ { i = 1 } ^ { m }$ as follows.
+
+$$
+\mathbf { w } ^ { * } = \mathop { \arg \operatorname* { m i n } } _ { \mathbf { w } } \frac { 1 } { m } \sum _ { i = 1 } ^ { m } \mathcal { L } ( f ( \mathbf { x } _ { i } ; \mathbf { w } ) , \mathbf { d } _ { i } ) + \lambda \Omega ( \mathbf { w } )
+$$
+
+where $\mathcal { L }$ is the loss function, which is usually cross-entropy loss for classification tasks. Here, the regularization term $\lambda \Omega ( \mathbf { w } )$ is added to simplify the solution, and $\lambda$ is set to zero for non-regularized cost function. A higher value of $\lambda$ means that stronger regularization is imposed.
+
+The most commonly used regularization function is a squared L2 norm: $\Omega ( \mathbf { w } ) = \lvert \lvert \mathbf { w } \rvert \rvert _ { 2 } ^ { 2 }$ , which is also called as weight decay in deep learning literature. This L2 regularizer has an effect of reducing the magnitude of the parameters w, and the simpler solution becomes less prone to over-fitting. On the other hand, the L1 regularizer $\Omega ( \mathbf { w } ) = | | \mathbf { w } | | _ { 1 }$ is often employed to induce sparsity in the model (i.e., make a portion of w zero). The sparse solution is often preferred to reduce computation time and memory consumption for deep learning since DNNs often require heavy computation and big memory space.
+
+With the gradient descent method, each model parameter at time $t$ , $\mathbf { w } _ { i } ^ { ( t ) }$ , is updated with the following formula:
+
+$$
+\mathbf { w } _ { i } ^ { ( t + 1 ) } = \mathbf { w } _ { i } ^ { ( t ) } - \alpha \left. \left( \frac { \partial \mathcal { L } } { \partial \mathbf { w } _ { i } } + \lambda \frac { \partial \Omega } { \partial \mathbf { w } _ { i } } \right) \right| _ { \mathbf { w } _ { i } = \mathbf { w } _ { i } ^ { ( t ) } }
+$$
+
+$$
+\frac { \partial \Omega } { \partial \mathbf { w } _ { i } } = \left\{ \begin{array} { l l } { 2 \times \mathbf { w } _ { i } ^ { ( t ) } , } & { \mathrm { i f } \ \Omega ( \mathbf { w } ) = | | \mathbf { w } | | _ { 2 } ^ { 2 } } \\ { 1 \times \mathrm { s i g n } ( \mathbf { w } _ { i } ^ { ( t ) } ) , } & { \mathrm { i f } \ \Omega ( \mathbf { w } ) = | | \mathbf { w } | | _ { 1 } \ \mathrm { a n d } \ \mathbf { w } _ { i } ^ { ( t ) } \neq 0 } \end{array} \right.
+$$
+
+where $\alpha$ is a learning rate. As L1 norm is not differentiable at 0, the formula doesn’t have value when $\mathbf { w } _ { i } ^ { ( t ) } = 0$ , but in practice, the subgradient 0 is often used. Please see Section 2.3 for more details. From the formula, we can see that L2 regularizer continuously reduces the magnitude of a parameter proportionally to it while L1 regularizer reduces the magnitude by a constant. In both regularizers, strong regularization thus means greatly reducing the magnitude of parameters.
+
+# 2.2 IMPOSING STRONG REGULARIZATION MAKES LEARNING FAIL.
+
+Strong regularization is especially useful for deep learning because the DNNs often contain a large number of parameters while the training data is limited in practice. However, we have observed a phenomenon where learning suddenly fails when strong regularization is imposed for gradient descent method, which is the most commonly used solver for deep learning. The example of the phenomenon is depicted in Figure 1. In the example, the architectures VGG-16 (Simonyan & Zisserman, 2014) and AlexNet (Krizhevsky et al., 2012) were employed for the data set CIFAR-100 (Krizhevsky & Hinton, 2009).2 As shown, the accuracy increases as we enforce more regularization. However, it suddenly drops to $1 . 0 \%$ after enforcing a little more regularization, which means that the model entirely fails to learn. The depicted training loss also indicates that it indeed learns faster with stronger regularization $\langle \lambda = 1 \overset { \overline { { \mathbf { \sigma } } } } { \times } 1 0 ^ { - 3 } \rangle$ ), but the training loss does not improve at all when even stronger regularization is imposed $( \lambda = 2 \times 1 0 ^ { - 3 }$ ).
+
+In order to look at this phenomenon in more detail, we show how gradients and their proportion change in Figure 2. As depicted in Figure 2a, a model with moderate L2 regularization $\lambda = 1 \times$
+
+![](images/67feb84bd6a8c45dada3179a3e5f105c3fcee1c97cdf3b9521a1b9197cd26248.jpg)  
+Figure 1: (a,b) Validation accuracies for different $\lambda$ when L1 and L2 regularization is applied to VGG-16 and AlexNet on the CIFAR-100 data set. Note the sharp accuracy drop. (c) Training loss when different $\lambda$ for L2 regularization is used for VGG-16 on CIFAR-100. Note that the regularization loss is excluded from the training loss. Best shown in color.
+
+![](images/0c889283c66edcc90acb2f2fd65b5d88f4c81094744dd6f37bd607c9b2a0ee67.jpg)  
+Figure 2: Gradients for different $\lambda$ by VGG-16 on CIFAR-100. (a) Average amount of gradient from $\mathcal { L }$ when L2 regularization is applied. (b) A close-up version of (a) with y-axis in log-scale. (c) The proportion of gradients from $\mathcal { L }$ to all gradients. Best shown in color.
+
+$1 0 ^ { - 3 }$ ) follows a path that has a relatively steep slope during the first 150 epoch, and then it converges with a gentle slope. However, a model with a little stronger L2 regularization $( \lambda = 2 \times 1 0 ^ { - 3 }$ ) does not follow a path that has a good slope, so it does not really have a chance to learn from gradients. A close-up view of this in the first 20 epochs is depicted in Figure 2b. The models with moderate L1 and L2 regularization seem to follow a good path in a couple of epochs. Through following the good path, the models keep the proportion of the gradients from $\mathcal { L }$ to all gradients dominant, especially for the first 150 epochs (Figure 2c). On the other hand, the models with a little stronger regularization fail to follow such path and the gradients from $\mathcal { L }$ decrease exponentially (Figure 2b). Since the magnitude of gradients from $\mathcal { L }$ decreases faster than that from $\Omega$ , the proportion of the latter to all gradients becomes dominant (Figure 2c), and it results in failure in learning. From this observation, we can see that there exists a tolerance level of regularization strength, which decides success or failure of entire learning.
+
+Why does the magnitude of the gradient from $\mathcal { L }$ decrease so fast? It is not difficult to see why the magnitude of $\frac { \triangledown \mathcal { L } } { \partial \mathbf { w } _ { i } }$ decreases so fast when the regularization is strong. In deep neural networks, the gradients are dictated by back-propagation. It is well known that the gradients at the $l ^ { \mathrm { t h } }$ layer are given by
+
+$$
+\frac { \partial \mathcal { L } } { \partial \mathbf { w } ^ { ( l ) } } = \pmb { \delta } ^ { ( l ) } ( \mathbf { a } ^ { ( l - 1 ) } ) ^ { T }
+$$
+
+where $\mathbf { a } ^ { ( l - 1 ) }$ is the output of the neurons at the $( l - 1 ) ^ { \mathrm { t h } }$ layer and $\delta ^ { ( l ) }$ is the $l ^ { \mathrm { t h } }$ -layer residual which follows the recursive relation
+
+$$
+\pmb { \delta } ^ { ( l ) } = ( \mathbf { w } ^ { ( l + 1 ) } ) ^ { T } \pmb { \delta } ^ { ( l + 1 ) } \odot \mathbf { a } ^ { \prime ( l ) }
+$$
+
+where $\odot$ and $\mathbf { a } ^ { \prime }$ denote the element-wise multiplications and derivatives of the activation function respectively.
+
+Using the recursive relation, we obtain
+
+$$
+\begin{array} { r c l } { \displaystyle \frac { \partial \mathcal { L } } { \partial \mathbf { w } ^ { ( l ) } } } & { = } & { \displaystyle ( \mathbf { w } ^ { ( l + 1 ) } ) ^ { T } \left( \mathbf { w } ^ { ( l + 2 ) } \right) ^ { T } \cdot \cdot \cdot \cdot \left( \mathbf { w } ^ { ( L ) } \right) ^ { T } \delta ^ { ( L ) } } \\ & & { \qquad \odot \mathbf { a } ^ { \prime ( L - 1 ) } \odot \mathbf { a } ^ { \prime ( L - 2 ) } \odot \cdots \odot \mathbf { a } ^ { \prime ( l + 1 ) } \odot \mathbf { a } ^ { \prime ( l ) } ( \mathbf { a } ^ { ( l - 1 ) } ) ^ { T } } \end{array}
+$$
+
+If the regularization is too strong, the weights would be significantly suppressed as shown in Figure 5b. From (5), since the gradients are proportional to the product of the weights at later layers (whose magnitudes are typically much less than 1 for strong regularization), they are even more suppressed.
+
+In fact, the suppression is more severe than what we have deduced above. The factor $\mathbf { a } ^ { ( l - 1 ) }$ in (5) could actually lead to further suppression to the gradients when the weights are very small, for the following reasons. First of all, we use ReLU as the activation function and it could be written as
+
+$$
+\operatorname { R e L U } ( x ) = x \ \Theta ( x )
+$$
+
+where $\Theta ( x )$ is the Heaviside step function. Using this, we could write
+
+$$
+\mathbf { a } ^ { ( l - 1 ) } = \left( \mathbf { w } ^ { ( l - 1 ) } \mathbf { a } ^ { ( l - 2 ) } \right) \odot \Theta \left( \mathbf { w } ^ { ( l - 1 ) } \mathbf { a } ^ { ( l - 2 ) } \right)
+$$
+
+Applying (7) recursively, we can see that $\mathbf { a } ^ { ( l - 1 ) }$ is proportional to the product of the weights at previous layers. Again, when the weights are suppressed by strong regularization, $\mathbf { a } ^ { ( l - 1 ) }$ would be suppressed correspondingly. Putting everything together, we can conclude that in the presence of strong regularization, the gradients are far more suppressed than the weights.
+
+Strictly speaking, the derivations above are valid only for fully-connected layers. For convolutional layers, the derivations are more complicated but similar. Our conclusions above would still be valid.
+
+Normalization Normalization techniques such as batch normalization (Ioffe & Szegedy, 2015) and weight normalization (Salimans & Kingma, 2016) can be possible approaches to prevent the $\mathcal { L }$ gradients from diminishing quickly. However, it has been shown that L2 regularization has no regularizing effect when combined with normalization but only influences on the effective learning rate, resulting in good performance (van Laarhoven, 2017). In other words, the normalization techniques do not really simplify the solution as the decrease of parameter magnitude is canceled by normalization. This does not meet our goal, which is to heavily simplify solutions to reduce over-fitting, so we propose an approach that meets our goal.
+
+# 2.3 OUR PROPOSED APPROACH: DELAYED STRONG REGULARIZATION
+
+Since we have seen that stronger regularization can result in better performance in Figure 1, we propose a method that is able to accommodate strong regularization. Specifically, we introduce a time-dependent regularization strength, $\lambda _ { t }$ , to the equation (2), and it is defined as
+
+$$
+\lambda _ { t } = { \left\{ \begin{array} { l l } { 0 } & { { \mathrm { i f ~ e p o c h } } ( t ) < \gamma } \\ { \lambda } & { { \mathrm { o t h e r w i s e } } } \end{array} \right. }
+$$
+
+where epoch $( t )$ gets the epoch number of the time step $t$ , and $\gamma$ is a hyper-parameter that is set through cross-validation. The formula means that we do not impose any regularization until $\gamma ^ { \mathrm { t h } }$ epoch, and then impose the strong regularization in each training step. The underlying hypothesis is that once the model follows a good learning path, i.e., the gradient from $\mathcal { L }$ is big enough, it won’t easily change its direction because of the steep slope, and thus, it can learn without failure. We empirically verify our hypothesis in the experiment section. The hyper-parameter $\gamma$ is relatively easy to set because the models often follow the good path in a couple of epochs, and once they follow such path, learning does not fail. We recommend using $2 \leq \gamma \leq 2 0$ . Please note that our approach is different from imposing a slightly weaker regularization throughout the whole training. The reduced amount by not skipping regularization for the first few epochs is negligible compared to the total reduced amount by regularization. In addition, we empirically show that our approach can achieve a much higher sparsity than the baseline in the parameter space.
+
+The proposed method is easy to implement, and the hyper-parameter is easy to set. Also, the method is very close to the traditional regularization method so that it inherits the traditional one’s good performance for non-strong regularization while it also achieves strong regularization. Although the method is very simple, we found that it shows the best accuracy among the approaches we tried in our preliminary experiments while it is the simplest. The preliminary experiments are further discussed in Appendix B.
+
+Proximal gradient algorithm for L1 regularizer Meanwhile, since L1 norm is not differentiable at zero, we employ the proximal gradient algorithm (Parikh et al., 2014), which enables us to obtain proper sparsity (i.e., guaranteed convergence) for non-smooth regularizers. We use the following update formulae:
+
+$$
+\begin{array} { r l } & { \mathbf { w } _ { i } ^ { ( t ^ { \prime } ) } = \mathbf { w } _ { i } ^ { ( t ) } - \alpha \ \frac { \partial \mathcal { L } } { \partial \mathbf { w } _ { i } } \bigg | _ { \mathbf { w } _ { i } = \mathbf { w } _ { i } ^ { ( t ) } } } \\ & { \mathbf { w } _ { i } ^ { ( t + 1 ) } = \mathrm { p r o x } _ { \alpha \lambda \Omega } ( \mathbf { w } _ { i } ^ { ( t ^ { \prime } ) } ) = S ( \mathbf { w } _ { i } ^ { ( t ^ { \prime } ) } , \alpha \lambda ) } \\ & { S ( a , z ) = \left\{ \begin{array} { l l } { a - z } & { \mathrm { i f ~ } a > z } \\ { a + z } & { \mathrm { i f ~ } a < - z } \\ { 0 } & { \mathrm { o t h e r w i s e } } \end{array} \right. } \end{array}
+$$
+
+where $S$ is a soft-thresholding operator. Basically, the algorithm assigns zero to a parameter if its next updated value is smaller than $\alpha \lambda$ . In other cases, it just decreases the magnitude of the parameter as usual.
+
+# 3 EXPERIMENTS
+
+We first evaluate the effectiveness of our proposed method with popular architectures, AlexNet (Krizhevsky et al., 2012) and VGG-16 (Simonyan & Zisserman, 2014) on the public data sets CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009). Then, we employ variations of VGG on another public data set SVHN (Netzer et al., 2011), in order to see the effect of the number of hidden layers on the tolerance level. Please note that we do not employ architectures that contain normalization techniques such as batch normalization (Ioffe & Szegedy, 2015), for the reason described in Section 2.2. The data set statistics are described in Table 1. VGG-11 and VGG-19 for SVHN contain 9.8 and 20.6 millions of parameters.
+
+Table 1: Data set statistics for CIFAR-10 and CIFAR-100.   
+
+<table><tr><td>Data Set</td><td>Image Resolution</td><td>Classes</td><td>Training Images per Class</td><td>Test Images per Class</td><td>AlexNet Parameters</td><td>VGG-16 Parameters</td></tr><tr><td>CIFAR-10</td><td>32×32</td><td>10</td><td>5000</td><td>1000</td><td>2.6M</td><td>15.2M</td></tr><tr><td>CIFAR-100</td><td>32×32</td><td>100</td><td>500</td><td>100</td><td>2.6M</td><td>15.3M</td></tr><tr><td>SVHN</td><td>32×32</td><td>10</td><td>7325.7 (avg.)</td><td>2603.2 (avg.)</td><td>1</td><td>15.2M</td></tr></table>
+
+Regularization is applied to all network parameters except bias terms. We use PyTorch3 framework for all experiments, and we use its official computer vision library4 for the implementations of the networks. In order to accommodate the data sets, we made some modifications to the networks. The kernel size of AlexNet’s max-pooling layers is changed from 3 to 2, and the first convolution layer’s padding size is changed from 2 to 5. All of its fully connected layers are modified to have 256 neurons. For VGG, we modified the fully connected layers to have 512 neurons. The output layers of both networks have 10 neurons for CIFAR-10 and SVHN, and 100 neurons for CIFAR100. The networks are learned by stochastic gradient descent algorithm with momentum of 0.9. The parameters are initialized according to He et al. (2015). The batch size is set to 128, and the initial learning rate is set to 0.05 and decays by a factor of 2 every 30 epochs during the whole 300-epoch training. In all experiments, we set $\gamma = 5$ . We did not find significantly different results for $2 \leq \gamma \leq 2 0$ . Please note that we still use drop out layers (with drop probability 0.5) and preprocess training data5 in order to report the extra performance boost on top of common regularization techniques.
+
+![](images/259bf6e95da2c0d6e74b0d8654c329a5fa9fcab0236570e73a67e1eb051f4289.jpg)  
+Figure 3: Accuracies obtained by VGG-16 with L1 and L2 regularization on CIFAR-100 (a,b,c) and CIFAR-10 (d,e,f). A green dotted horizontal line is an accuracy obtained by a model without L1/L2 regularization (but with dropout). Accuracy for different sparsity is shown in (c) and (f). The error bars indicate $9 5 \%$ confidence interval.
+
+AlexNet and VGG-16 are experimented for different regularization methods (L1 and L2) and different data sets (CIFAR-10 and CIFAR-100), yielding 8 combinations of experiment sets. Then, VGG-11, VGG-16, and VGG-19 are experimented for L1 and L2 regularization methods on SVHN, yielding 6 experiment sets. For each experiment set, we set the baseline method as the one with well-tuned L1 or L2 regularization but without our time-dependent regularization strength. For each regularization, we try more than 10 different values of $\lambda$ , and for each value, we report average accuracy of three independent runs and report $9 5 \%$ confidence interval. We perform statistical significance test (t-test) for the improvement over the baseline method and report the p-value. We also report sparsity of each trained model, which is the proportion of the number of zero-valued parameters to the number of all parameters. Please note that we mean the sparsity by the one actually derived by the models, not by pruning parameters with threshold after training.
+
+# 3.1 EXPERIMENT RESULTS ON CIFAR-10 AND CIFAR-100
+
+The experiment results by VGG-16 are depicted in Figure 3. As we investigated in Section 2.2, the baseline method suddenly fails beyond certain values of tolerance level. However, our proposed method does not fail for higher values of $\lambda$ . As a result, our model can achieve higher accuracy as well as higher sparsity. In practice, L2 regularization is used more often than L1 regularization due to its superior performance, and this is true for our VGG-16 experiments too. Using L2 regularization, our model improves the model without L1 or L2 regularization but with dropout, by $1 4 . 4 \%$ in accuracy, which is about $24 \%$ of error rate improvement. Tuning L2 regularization parameter is difficult as the curves have somewhat sharp peak, but our proposed method ease the problem to some extent by preventing the sharp drop. Our L1 regularizer obtains much better sparsity for the similar level of accuracy (Figure 3c), which means that strong regularization plays an important role in compressing neural networks. The improvement is more prominent on CIFAR-100 than on
+
+![](images/a30578c48bb27c6b33f2220e09936540058b7c489b5e455745c29530a08ff6cd.jpg)  
+Figure 4: Accuracies obtained by AlexNet with L1 and L2 regularization on CIFAR-100 (a,b,c) and CIFAR-10 (d,e,f). A green dotted horizontal line is an accuracy obtained by a model without L1/L2 regularization (but with dropout). Accuracy for different sparsity is shown in (c) and (f). The error bars indicate $9 5 \%$ confidence interval.
+
+CIFAR-10, and we think this is because over-fitting can more likely occur on CIFAR-100 as there are less images per class than on CIFAR-10.
+
+The experiment results by AlexNet are depicted in Figure 4. Again, our proposed method achieves higher accuracy and sparsity in general. Unlike VGG-16, we obtain more improvement over baseline with L1 regularization than with L2 regularization. In addition, the curves make sharper peaks than those by VGG-16 especially for the sparsity regularizer (L1).
+
+Interestingly, our proposed method often obtains higher accuracy even when the baseline does not fail on CIFAR-10, and this is only prominent when the regularization strength is relatively strong (better shown in Figure 3f, 4c, 4f). This may be because avoiding strong regularization in the early stage of training can help the model to explore more spaces freely, and the better exploration results in finding superior local optima.
+
+The overall experiment results are shown in Table 2. It shows that there is more performance improvement by L1/L2 regularization on VGG-16 than on AlexNet, which is reasonable since VGG-16 contains about 6 times more parameters so that it is more prone to over-fitting. Our proposed model always improves the baselines by up to $3 . 8 9 \%$ , except AlexNet with L1 regularization on CIFAR10, and most (6 out of 7) improvements are statistically significant $( \mathrm { p } ; 0 . 0 5 )$ . Our L1 regularization models always obtain higher sparsity with compression rate up to $4 . 2 \times$ than baselines, meaning that our model is promising for compressing neural networks.
+
+We also show in Figure 5 how gradients and weights change when our method and the baseline are applied. We hypothesized that if the model reaches an “active learning” phase with an elevated gradient amount, it does not suffer from vanishing gradients any more even when strong regularization is enforced. The Figure 5a shows that our model indeed reaches there by skipping strong regularization for the first five epochs, and and it keeps learning even after strong regularization is enforced. In Figure 5b, although the same strong regularization is enforced since epoch 5, the magnitude of weights in our model stops decreasing around epoch 20, while that in baseline (green dotted line) keeps decreasing towards zero. This means that our model can cope with strong regularization, and it maintains its equilibrium between gradients from $\mathcal { L }$ and those from regularization.
+
+Table 2: Overall experiment results. The $9 5 \%$ confidence interval is reported after $\pm$ symbol. The improvement is calculated by comparing with baseline methods. Compression rate is calculated by how much the regularization reduces the number of non-zero-valued parameters while having an accuracy similar to L1 baseline. Note that when no L1/L2 regularization is imposed, dropout is still employed.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="3">CIFAR-100</td><td colspan="2">CIFAR-10</td></tr><tr><td></td><td>Sparsity</td><td>Acc. (%)</td><td>Sparsity</td><td>Acc. (%)</td></tr><tr><td rowspan="9">VGG-16</td><td>No L1/L2</td><td>0</td><td>62.08 ± 0.81</td><td>0</td><td>90.80± 0.23</td></tr><tr><td>L2baseline</td><td>0</td><td>69.16± 0.46</td><td>0</td><td>92.42 ± 0.16</td></tr><tr><td>L2 ours</td><td>0</td><td>71.01 ± 0.33</td><td>0</td><td>92.60 ± 0.16</td></tr><tr><td>Acc.improvement</td><td>1</td><td>+2.67% (p=0.002)</td><td>1</td><td>+0.19% (p=0.103)</td></tr><tr><td>L1baseline</td><td>0.269</td><td>66.94 ± 0.24</td><td>0.808</td><td>91.29± 0.16</td></tr><tr><td>L1 ours</td><td>0.303</td><td>67.55 ± 0.12</td><td>0.845</td><td>91.55 ± 0.10</td></tr><tr><td>Acc.improvement</td><td></td><td>+0.91% (p=0.011)</td><td></td><td>+0.28% (p=0.037)</td></tr><tr><td>Li ours (sparse) Compression rate over</td><td>0.697</td><td>67.06± 0.62</td><td>0.926</td><td>91.38± 0.05</td></tr><tr><td>L1 baseline</td><td>2.4×</td><td></td><td>2.6×</td><td></td></tr><tr><td rowspan="8">AlexNet</td><td>No L1/L2</td><td>0</td><td>43.09±0.25</td><td>0</td><td>75.05± 0.20</td></tr><tr><td>L2 baseline</td><td>0</td><td>46.91 ± 0.15</td><td>0</td><td>78.66 ± 0.17</td></tr><tr><td>L2 ours</td><td>0</td><td>47.64 ± 0.33</td><td>0</td><td>78.65 ± 0.29</td></tr><tr><td>Acc.improvement</td><td>-</td><td>+1.56% (p=0.017)</td><td>1</td><td>-0.01%</td></tr><tr><td>L1baseline</td><td>0.219</td><td>45.70± 0.10</td><td>0.766</td><td>76.87 ± 0.24</td></tr><tr><td>L1 ours</td><td>0.632</td><td>47.48 ± 0.29</td><td>0.794</td><td>77.63 ± 0.34</td></tr><tr><td>Acc.improvement</td><td>1</td><td>+3.89% (p=0.002)</td><td>1</td><td>+0.99% (p=0.013)</td></tr><tr><td>Lf ours (sparse)</td><td>0.814</td><td>45.77±0.32</td><td>0.877</td><td>76.90± 0.227</td></tr><tr><td></td><td>Compression rate over L1 baseline</td><td>4.2×</td><td></td><td>1.9×</td><td></td></tr></table>
+
+![](images/893965a3fec3eb65e2bc6c4d473e0d66cb82d0d2558b411f664e2ae45ed153dd.jpg)  
+Figure 5: Experiment results by L2 regularization with VGG-16 on CIFAR-100. The results are from baseline method unless it is labeled as “ours”. Our proposed Delayed Strong Regularization does not fail in learning.
+
+![](images/880d6f907b7051ce27d5933c2ac10e7ae3be299a3c0ffb893254f286ca5d1f87.jpg)  
+Figure 6: Accuracies obtained by variations of VGG with L2 regularization on SVHN. A green dotted horizontal line is an accuracy obtained by a model without L2 regularization (but with dropout). The error bars indicate $9 5 \%$ confidence interval.
+
+Table 3: Experiment results on SVHN. The improvement is calculated by comparing with baseline methods. Note that when no L1/L2 regularization is imposed, dropout is still employed.   
+
+<table><tr><td rowspan="2">Model</td><td colspan="2">VGG-11</td><td colspan="2">VGG-16</td><td colspan="2">VGG-19</td></tr><tr><td>Sparsity</td><td>Acc. (%)</td><td>Sparsity</td><td>Acc. (%)</td><td>Sparsity</td><td>Acc. (%)</td></tr><tr><td>No L1/L2</td><td>0</td><td>94.27 ± 0.13</td><td>0</td><td>95.10± 0.22</td><td>0</td><td>95.20± 0.10</td></tr><tr><td>L2 baseline</td><td>0</td><td>94.82 ± 0.02</td><td>0</td><td>95.38± 0.10</td><td>0</td><td>95.45± 0.14</td></tr><tr><td>L2 ours</td><td>0</td><td>94.84 ± 0.04</td><td>0</td><td>95.53 ± 0.07</td><td>0</td><td>95.74 ± 0.07</td></tr><tr><td>Acc.improvement</td><td>-</td><td>+0.02% (p=0.200)</td><td>-</td><td>+0.16% (p=0.047)</td><td>-</td><td>+0.30% (p=0.019)</td></tr><tr><td>L1 baseline</td><td>0.519</td><td>94.68±0.08</td><td>0.450</td><td>95.34 ± 0.11</td><td>0.122</td><td>95.37 ± 0.11</td></tr><tr><td>Ll ours</td><td>0.621</td><td>94.78 ± 0.07</td><td>0.795</td><td>95.38 ± 0.11</td><td>0.518</td><td>95.50 ± 0.15</td></tr><tr><td>Acc.improvement</td><td></td><td>+0.11% (p=0.056)</td><td>=</td><td>+0.04% (p=0.324)</td><td>=</td><td>+0.13% (p=0.180)</td></tr><tr><td>L1 ours (sparse) Compression rate over</td><td>0.845</td><td>94.710.01</td><td>70.795</td><td>95.38±0.11</td><td>0.911</td><td>95.410.07</td></tr><tr><td>L1 baseline</td><td>3.1×</td><td></td><td>2.7×</td><td></td><td>9.9×</td><td></td></tr></table>
+
+# 3.2 EXPERIMENT RESULTS ON SVHN
+
+The analysis in Section 2.2 implies that the number of hidden layers would affect the tolerance level when strong regularization is imposed. That is, if there are more hidden layers in the neural network architecture, the learning will fail more easily by strong regularization. In order to check the hypothesis empirically, we employ variations of the VGG architecture, i.e., VGG-11, VGG-16, and VGG-19, which contain 11, 16, and 19 hidden layers, respectively. We experiment them on the SVHN data set.
+
+The results by L2 regularization are depicted in Figure 6. As shown, the peak of our method’s performance is formed around $\lambda = 1 \times \bar { 1 } 0 ^ { - 3 }$ . As more hidden layers are added to the network, the tolerance level where the performance suddenly drops by the baseline is shifted to left, as hypothesized by our analysis. The results by L1 regularization are in Appendix A, and it is shown that VGG-19 more easily fails as the parameters become more sparse. The overall experiment results are shown in Table 3. As the method without L1/L2 regularization already performs well on this data set and there are relatively many training images per class, the improvement by L1/L2 regularization is not big. Our method still outperforms the baseline in all experiments (6 out of 6), but the improvement is less statistically significant compared to CIFAR-10 and CIFAR-100 data sets. The compression rate is especially good for VGG-19 mainly because its tolerance level is low so that the baseline can only achieve low sparsity.
+
+# 4 RELATED WORK
+
+The related work is partially covered in Section 1, and we extend other related work here. It has been shown that L2 regularization is important for training DNNs (Krizhevsky et al., 2012; Deng et al., 2013). Although there has been a new regularization method such as dropout, L2 regularization has been shown to reduce the test error effectively when combined with dropout (Srivastava et al., 2014). Meanwhile, L1 regularization has also been used often in order to obtain sparse solutions. To reduce computation and power consumption, L1 regularization and its variations such as group sparsity regularization has been promising for deep neural networks (Wen et al., 2016; Scardapane et al., 2017; Yoon & Hwang, 2017). However, for both L1 and L2 regularization, the phenomenon that learning fails with strong regularization has not been emphasized previously. Bergstra & Bengio (2012) showed that tuning hyper-parameters such as L2 regularization strength can be effectively done through random search instead of grid search, but they did not study how and why learning fails or how strong regularization can be successfully achieved. Yosinski et al. (2015) visualized activations to understand deep neural networks and showed that strong L2 regularization fails to learn. However, it was still not shown how and why learning fails and how strong regularization can be achieved. To the best of our knowledge, there is no existing work that is dedicated to studying the phenomenon that learning fails with strong regularization and to proposing a method that can avoid the failure.
+
+# 5 DISCUSSION
+
+In this work, we studied the problem of achieving strong regularization for deep neural networks. Strong regularization with gradient descent algorithm easily fails for deep neural networks, but few work addressed this phenomenon in detail. We provided investigation and analysis of the phenomenon, and we found that there is a strict tolerance level of regularization strength. To avoid this problem, we proposed a novel but simple method: Delayed Strong Regularization. We performed experiments with fine tuning of regularization strength. Evaluation results show that (1) our model successfully achieves strong regularization on deep neural networks, verifying our hypothesis that the model will keep learning once it reaches an “active learning” phase, (2) with strong regularization, our model obtains higher accuracy and sparsity, (3) the number of hidden layers in neural networks affects the tolerance level, and (4) L1/L2 regularization is difficult to tune, but it can yield great performance boost when tuned well.
+
+There are limitations in this work. Our proposed method can be especially useful when strong regularization is desired. For example, deep learning projects that cannot afford a huge labeled data set can benefit from our method. However, strong regularization may not be necessary in some other cases where the large labeled data set is available or the networks do not contain many parameters. In addition, our experiments were not performed on a bigger data set such as ImageNet data set. We need to fine-tune the models with different regularization parameters, and we also need multiple training sessions of each model to obtain confidence interval. For example, the experiment results in Figure 3 and 4 include 750 training sessions in total. This is something we cannot afford with ImageNet data set, which requires several weeks of training for EACH session (unless we have GPU clusters). Our approach cannot be applied to architectures containing normalization techniques for the reason in Section 2.2. We actually tried to intentionally exclude normalization part from Residual Networks (He et al., 2016) and train the model to see if we can apply our method to non-normalized Residual Networks. However, we could not control the exploding gradients caused by the exclusion of normalization.
+
+Our work can be further extended in several ways. Since our model can achieve strong regularization, it will be interesting to see how the strongly regularized model performs if combined with pruning-related methods (Han et al., 2015; 2016). We applied our approach to only L1 and L2 regularizers, but applying it to other regularizers such as group sparsity regularizers will be promising as they are often employed for DNNs to compress networks. Lastly, our proposed Delayed Strong Regularization is very simple, so one can easily extend it to more complicated methods. All these directions are left as our future work.
+
+# REFERENCES
+
+James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012.
+
+Li Deng, Geoffrey Hinton, and Brian Kingsbury. New types of deep neural network learning for speech recognition and related applications: An overview. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 8599–8603. IEEE, 2013.
+
+Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems, pp. 1135–1143, 2015.
+
+Song Han, Jeff Pool, Sharan Narang, Huizi Mao, Shijian Tang, Erich Elsen, Bryan Catanzaro, John Tran, and William J Dally. Dsd: Regularizing deep neural networks with dense-sparse-dense training flow. arXiv preprint arXiv:1607.04381, 2016.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015.
+
+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.
+
+Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015.
+
+Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 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.
+
+Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 5, 2011.
+
+Neal Parikh, Stephen Boyd, et al. Proximal algorithms. Foundations and Trends $\textsuperscript { \textregistered }$ in Optimization, 1(3):127–239, 2014.
+
+Kristiaan Pelckmans, Johan AK Suykens, and Bart De Moor. Morozov, ivanov and tikhonov regularization based ls-svms. In International Conference on Neural Information Processing, pp. 1216–1222. Springer, 2004.
+
+Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016.
+
+Simone Scardapane, Danilo Comminiello, Amir Hussain, and Aurelio Uncini. Group sparse regularization for deep neural networks. Neurocomputing, 241:81–89, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.
+
+Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014.
+
+Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), pp. 267–288, 1996.
+
+Twan van Laarhoven. L2 regularization versus batch and weight normalization. arXiv preprint arXiv:1706.05350, 2017.
+
+Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016.
+
+![](images/0bab4650ce56fbb965b1d1511b7a979debb8d3f8bd9d5c1ad4b95d5a14cde7ff.jpg)  
+Figure 7: Accuracies obtained by variations of VGG with L1 regularization on SVHN. A green dotted horizontal line is an accuracy obtained by a model without L1 regularization (but with dropout). Accuracy for different sparsity is shown in (d), (e), and (f). The error bars indicate $9 5 \%$ confidence interval.
+
+Jaehong Yoon and Sung Ju Hwang. Combined group and exclusive sparsity for deep neural networks. In International Conference on Machine Learning, pp. 3958–3966, 2017.
+
+Jason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. arXiv preprint arXiv:1506.06579, 2015.
+
+# Appendices
+
+# A EXPERIMENT RESULTS ON SVHN BY L1 REGULARIZER
+
+To empirically check the effect of the number of hidden layers on the tolerance level, we experimented variations of VGG on SVHN, and we showed the results by L2 regularizer in Section 3.2. Here, we show the results by L1 regularizer in Figure 7. As more hidden layers are included to the network, the tolerance level where the baseline method suddenly fails is shifted to left. Such pattern in baseline method is more clearly shown in the accuracy vs. sparsity plots. VGG-19 fails to learn even when it loses only $27 \%$ of its parameters, whereas VGG-11 can still learn after losing $84 \%$ of its parameters.
+
+# B PRELIMINARY EXPERIMENTS
+
+The reason why we proposed a very simple method is that it is effective while it is simple to implement. The only additional hyper-parameter, which is the number of initial epochs to skip regularization, is also not difficult to set. We think that the proposed method is very similar to the traditional regularization method so that it inherits the traditional one’s good performance for non-strong regularization while it also achieves strong regularization.
+
+We actually tried a couple more approaches other than the proposed one in our preliminary experiments. We found that the proposed one shows the best accuracy among the approaches we tried while it is the simplest. For example, we tried an approach that can be regarded as a warm-start strategy. It starts with the regularization parameter $\lambda _ { t } = 0$ , and then it gradually increases $\lambda _ { t }$ to $\lambda$ for $\gamma$ epochs, where $\gamma > = 0$ and it is empirically set. We found that it can achieve strong regularization, but its best accuracy is similar to or slightly lower than that of our proposed approach.
+
+We also tried a method that is similar to Ivanov regularization (Pelckmans et al., 2004). In this method, the regularization term is applied only when the L1 norm of the weights is greater than a certain threshold. To enforce strong regularization, we set $\lambda$ just above the tolerance level that is found by the baseline method. However, this method did not accomplish any learning. The reason is that, to reach the level of L1 norm that is low enough, the model needs to go through the strong regularization for the first few epochs, and the neurons already lose its learning ability during this period like the baseline method. If we set $\lambda$ below the tolerance level, it cannot reach the desired L1 norm without strong regularization, and thus the performance is inferior to our proposed method.
+
+Meanwhile, an approach that applies strong regularization first and then continuously reduces the regularization strength is used in sparse learning for convex optimization. This approach is opposite to our approach in that ours avoids strong regularization for the first few epochs and then apply strong regularization afterwards. We performed a simple experiment with VGG-16 on CIFAR-100 to see if the approach can perform well for deep neural networks. We set the initial regularization parameter $\lambda = \overset { \cdot } { 2 } \times 1 0 ^ { - 3 }$ and $\lambda = 6 \times 1 0 ^ { - 5 }$ for L2 and L1 regularization, respectively, which are just above the ”tolerance level”. Then, we continuously reduced $\lambda _ { t }$ to zero throughout the training session. The trained models didn’t show any improvement over ”random guess”, which means that they were not able to learn. Once the strong regularization is enforced in the beginning, the magnitudes of weights decrease quickly. This in turn drives the magnitudes of gradients to diminish exponentially in deep neural networks as explained in Section 2.2, and thus, the model loses its ability to learn after a short period of strong regularization.

parse/train/Bys_NzbC-/Bys_NzbC-_content_list.json

@@ -0,0 +1,1291 @@
+[
+    {
+        "type": "text",
+        "text": "ACHIEVING STRONG REGULARIZATION FOR DEEP NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "L1 and L2 regularizers are critical tools in machine learning due to their ability to simplify solutions. However, imposing strong L1 or L2 regularization with gradient descent method easily fails, and this limits the generalization ability of the underlying neural networks. To understand this phenomenon, we investigate how and why learning fails for strong regularization. Specifically, we examine how gradients change over time for different regularization strength and provide an analysis why the gradients diminish so fast when strong regularization is imposed. We find that there exists a tolerance level of regularization strength, where the learning completely fails if the regularization strength goes beyond it. We propose a simple but novel method, Delayed Strong Regularization, in order to moderate the tolerance level. Experiment results show that our proposed approach indeed achieves strong regularization for both L1 and L2 regularizers and improves both accuracy and sparsity on public data sets. Our source code is published.1 ",
+        "bbox": [
+            233,
+            266,
+            764,
+            446
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            473,
+            334,
+            488
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Regularization has been very common for machine learning to prevent over-fitting and to obtain sparse solutions. Deep neural networks (DNNs), which have shown huge success in many tasks such as computer vision (Krizhevsky et al., 2012; Simonyan & Zisserman, 2014; He et al., 2016) and speech recognition (Hinton et al., 2012), often contain a number of parameters in multiple layers with non-linear activation functions, in order to gain enough expressive power. However, DNNs with many parameters are often prone to over-fitting, so the need for regularization has been emphasized. While new regularization techniques such as dropout (Srivastava et al., 2014) and pruning (Han et al., 2015) have been proposed to solve the problem, the traditional regularization techniques using L1 or L2 norms have cooperated with them to further improve the performance significantly. L1 regularization, often called Lasso (Tibshirani, 1996), obtains sparse solutions so that the required memory and power consumption are reduced while keeping reasonable accuracy. On the other hand, L2 regularization smooths the parameter distribution and reduces the magnitude of parameters, so the resulting solution is simple (i.e., less prone to over-fitting) and effective. Indeed, our empirical results show that applying strong L2 regularization to the deep neural networks that already has dropout layers can reduce the error rate by up to $24 \\%$ on a public data set. ",
+        "bbox": [
+            174,
+            506,
+            825,
+            712
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Strong regularization is especially desired when the model contains too many parameters for the given amount of training data. This is often the case for deep learning tasks in practice because DNNs often contain millions of parameters while labeled training data set is limited and expensive. However, imposing strong L1 or L2 regularization on DNNs is difficult for gradient descent method due to the vanishing gradient problem. If we impose too strong regularization, the gradient from regularization becomes dominant, and DNNs stop learning. In this paper, we first study the interesting phenomenon that strong regularization fails in learning. We also provide an analysis why the gradients diminish so quickly that learning completely fails. Then, we propose a simple yet effective solution, Delayed Strong Regularization, which carries a time-dependent schedule of regularization strength. We find that we can overcome the failure in learning by waiting for the model to reach an “active learning” phase, where the gradients’ magnitudes are significant, and then enforcing strong regularization. Delayed Strong Regularization enables us to obtain the superior performance that is otherwise hidden by learning failure in deep networks. The proposed approach is general and does not require any additional computation. The experiment results indicate that the proposed approach indeed achieves strong regularization, consistently yielding even higher accuracy and higher compression rate that could not be achieved. ",
+        "bbox": [
+            174,
+            719,
+            825,
+            900
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 PROBLEM ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            166,
+            379,
+            183
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            196,
+            316,
+            212
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Let us denote a generic DNN by $\\mathbf { y } = f ( \\mathbf { x } ; \\mathbf { w } )$ where $\\mathbf { x } \\in \\mathbb { R } ^ { d }$ is an input vector, $\\mathbf { w } \\in \\mathbb { R } ^ { n }$ is a flattened vector of all parameters in the network $f$ , and $\\mathbf { y } \\in \\mathbb { R } ^ { c }$ is an output vector after feed-forwarding $\\mathbf { x }$ through multiple layers in $f$ . The network $f$ is trained by finding optimal set of w by minimizing the cost function within the training data $\\{ \\mathbf { x } _ { i } , \\mathbf { d } _ { i } \\} _ { i = 1 } ^ { m }$ as follows. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            280
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/51102b3b411b8e58aa615d4d3c5e37f659cdab62b44e2a3f77466b972bdf4afb.jpg",
+        "text": "$$\n\\mathbf { w } ^ { * } = \\mathop { \\arg \\operatorname* { m i n } } _ { \\mathbf { w } } \\frac { 1 } { m } \\sum _ { i = 1 } ^ { m } \\mathcal { L } ( f ( \\mathbf { x } _ { i } ; \\mathbf { w } ) , \\mathbf { d } _ { i } ) + \\lambda \\Omega ( \\mathbf { w } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            336,
+            285,
+            660,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { L }$ is the loss function, which is usually cross-entropy loss for classification tasks. Here, the regularization term $\\lambda \\Omega ( \\mathbf { w } )$ is added to simplify the solution, and $\\lambda$ is set to zero for non-regularized cost function. A higher value of $\\lambda$ means that stronger regularization is imposed. ",
+        "bbox": [
+            174,
+            330,
+            825,
+            373
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The most commonly used regularization function is a squared L2 norm: $\\Omega ( \\mathbf { w } ) = \\lvert \\lvert \\mathbf { w } \\rvert \\rvert _ { 2 } ^ { 2 }$ , which is also called as weight decay in deep learning literature. This L2 regularizer has an effect of reducing the magnitude of the parameters w, and the simpler solution becomes less prone to over-fitting. On the other hand, the L1 regularizer $\\Omega ( \\mathbf { w } ) = | | \\mathbf { w } | | _ { 1 }$ is often employed to induce sparsity in the model (i.e., make a portion of w zero). The sparse solution is often preferred to reduce computation time and memory consumption for deep learning since DNNs often require heavy computation and big memory space. ",
+        "bbox": [
+            173,
+            378,
+            825,
+            478
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "With the gradient descent method, each model parameter at time $t$ , $\\mathbf { w } _ { i } ^ { ( t ) }$ , is updated with the following formula: ",
+        "bbox": [
+            176,
+            486,
+            821,
+            515
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0b883349ccb9dea05e5eefdc827e99bd4d402884ea17d29c6990a57da396927d.jpg",
+        "text": "$$\n\\mathbf { w } _ { i } ^ { ( t + 1 ) } = \\mathbf { w } _ { i } ^ { ( t ) } - \\alpha \\left. \\left( \\frac { \\partial \\mathcal { L } } { \\partial \\mathbf { w } _ { i } } + \\lambda \\frac { \\partial \\Omega } { \\partial \\mathbf { w } _ { i } } \\right) \\right| _ { \\mathbf { w } _ { i } = \\mathbf { w } _ { i } ^ { ( t ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            513,
+            611,
+            551
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/03974a76326e80f945fb39157bd8790f87831a627ecb19e7d83f00cc022df24e.jpg",
+        "text": "$$\n\\frac { \\partial \\Omega } { \\partial \\mathbf { w } _ { i } } = \\left\\{ \\begin{array} { l l } { 2 \\times \\mathbf { w } _ { i } ^ { ( t ) } , } & { \\mathrm { i f } \\ \\Omega ( \\mathbf { w } ) = | | \\mathbf { w } | | _ { 2 } ^ { 2 } } \\\\ { 1 \\times \\mathrm { s i g n } ( \\mathbf { w } _ { i } ^ { ( t ) } ) , } & { \\mathrm { i f } \\ \\Omega ( \\mathbf { w } ) = | | \\mathbf { w } | | _ { 1 } \\ \\mathrm { a n d } \\ \\mathbf { w } _ { i } ^ { ( t ) } \\neq 0 } \\end{array} \\right.\n$$",
+        "text_format": "latex",
+        "bbox": [
+            307,
+            554,
+            702,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha$ is a learning rate. As L1 norm is not differentiable at 0, the formula doesn’t have value when $\\mathbf { w } _ { i } ^ { ( t ) } = 0$ , but in practice, the subgradient 0 is often used. Please see Section 2.3 for more details. From the formula, we can see that L2 regularizer continuously reduces the magnitude of a parameter proportionally to it while L1 regularizer reduces the magnitude by a constant. In both regularizers, strong regularization thus means greatly reducing the magnitude of parameters. ",
+        "bbox": [
+            174,
+            595,
+            826,
+            670
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 IMPOSING STRONG REGULARIZATION MAKES LEARNING FAIL. ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            685,
+            655,
+            700
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Strong regularization is especially useful for deep learning because the DNNs often contain a large number of parameters while the training data is limited in practice. However, we have observed a phenomenon where learning suddenly fails when strong regularization is imposed for gradient descent method, which is the most commonly used solver for deep learning. The example of the phenomenon is depicted in Figure 1. In the example, the architectures VGG-16 (Simonyan & Zisserman, 2014) and AlexNet (Krizhevsky et al., 2012) were employed for the data set CIFAR-100 (Krizhevsky & Hinton, 2009).2 As shown, the accuracy increases as we enforce more regularization. However, it suddenly drops to $1 . 0 \\%$ after enforcing a little more regularization, which means that the model entirely fails to learn. The depicted training loss also indicates that it indeed learns faster with stronger regularization $\\langle \\lambda = 1 \\overset { \\overline { { \\mathbf { \\sigma } } } } { \\times } 1 0 ^ { - 3 } \\rangle$ ), but the training loss does not improve at all when even stronger regularization is imposed $( \\lambda = 2 \\times 1 0 ^ { - 3 }$ ). ",
+        "bbox": [
+            174,
+            712,
+            825,
+            864
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to look at this phenomenon in more detail, we show how gradients and their proportion change in Figure 2. As depicted in Figure 2a, a model with moderate L2 regularization $\\lambda = 1 \\times$ ",
+        "bbox": [
+            176,
+            872,
+            821,
+            900
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/67feb84bd6a8c45dada3179a3e5f105c3fcee1c97cdf3b9521a1b9197cd26248.jpg",
+        "image_caption": [
+            "Figure 1: (a,b) Validation accuracies for different $\\lambda$ when L1 and L2 regularization is applied to VGG-16 and AlexNet on the CIFAR-100 data set. Note the sharp accuracy drop. (c) Training loss when different $\\lambda$ for L2 regularization is used for VGG-16 on CIFAR-100. Note that the regularization loss is excluded from the training loss. Best shown in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            104,
+            807,
+            238
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/0c889283c66edcc90acb2f2fd65b5d88f4c81094744dd6f37bd607c9b2a0ee67.jpg",
+        "image_caption": [
+            "Figure 2: Gradients for different $\\lambda$ by VGG-16 on CIFAR-100. (a) Average amount of gradient from $\\mathcal { L }$ when L2 regularization is applied. (b) A close-up version of (a) with y-axis in log-scale. (c) The proportion of gradients from $\\mathcal { L }$ to all gradients. Best shown in color. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            325,
+            805,
+            469
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "$1 0 ^ { - 3 }$ ) follows a path that has a relatively steep slope during the first 150 epoch, and then it converges with a gentle slope. However, a model with a little stronger L2 regularization $( \\lambda = 2 \\times 1 0 ^ { - 3 }$ ) does not follow a path that has a good slope, so it does not really have a chance to learn from gradients. A close-up view of this in the first 20 epochs is depicted in Figure 2b. The models with moderate L1 and L2 regularization seem to follow a good path in a couple of epochs. Through following the good path, the models keep the proportion of the gradients from $\\mathcal { L }$ to all gradients dominant, especially for the first 150 epochs (Figure 2c). On the other hand, the models with a little stronger regularization fail to follow such path and the gradients from $\\mathcal { L }$ decrease exponentially (Figure 2b). Since the magnitude of gradients from $\\mathcal { L }$ decreases faster than that from $\\Omega$ , the proportion of the latter to all gradients becomes dominant (Figure 2c), and it results in failure in learning. From this observation, we can see that there exists a tolerance level of regularization strength, which decides success or failure of entire learning. ",
+        "bbox": [
+            173,
+            549,
+            825,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Why does the magnitude of the gradient from $\\mathcal { L }$ decrease so fast? It is not difficult to see why the magnitude of $\\frac { \\triangledown \\mathcal { L } } { \\partial \\mathbf { w } _ { i } }$ decreases so fast when the regularization is strong. In deep neural networks, the gradients are dictated by back-propagation. It is well known that the gradients at the $l ^ { \\mathrm { t h } }$ layer are given by ",
+        "bbox": [
+            174,
+            732,
+            825,
+            792
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/04f333ddb3c2405a59fa6c1786af96d057f8dbe2d60eb267fd569a56d70e650b.jpg",
+        "text": "$$\n\\frac { \\partial \\mathcal { L } } { \\partial \\mathbf { w } ^ { ( l ) } } = \\pmb { \\delta } ^ { ( l ) } ( \\mathbf { a } ^ { ( l - 1 ) } ) ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            797,
+            566,
+            829
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { a } ^ { ( l - 1 ) }$ is the output of the neurons at the $( l - 1 ) ^ { \\mathrm { t h } }$ layer and $\\delta ^ { ( l ) }$ is the $l ^ { \\mathrm { t h } }$ -layer residual which follows the recursive relation ",
+        "bbox": [
+            174,
+            835,
+            825,
+            866
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e90c6462535fabffeaab904983ae2735c5779cf57dd07e0bf3453f97dead17a3.jpg",
+        "text": "$$\n\\pmb { \\delta } ^ { ( l ) } = ( \\mathbf { w } ^ { ( l + 1 ) } ) ^ { T } \\pmb { \\delta } ^ { ( l + 1 ) } \\odot \\mathbf { a } ^ { \\prime ( l ) }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            868,
+            593,
+            890
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\odot$ and $\\mathbf { a } ^ { \\prime }$ denote the element-wise multiplications and derivatives of the activation function respectively. ",
+        "bbox": [
+            174,
+            895,
+            826,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Using the recursive relation, we obtain ",
+        "bbox": [
+            176,
+            103,
+            428,
+            118
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6135beb7d4f727ead8303e17d457ab9afad45473dc5ca64a5bc62dc4d07e9047.jpg",
+        "text": "$$\n\\begin{array} { r c l } { \\displaystyle \\frac { \\partial \\mathcal { L } } { \\partial \\mathbf { w } ^ { ( l ) } } } & { = } & { \\displaystyle ( \\mathbf { w } ^ { ( l + 1 ) } ) ^ { T } \\left( \\mathbf { w } ^ { ( l + 2 ) } \\right) ^ { T } \\cdot \\cdot \\cdot \\cdot \\left( \\mathbf { w } ^ { ( L ) } \\right) ^ { T } \\delta ^ { ( L ) } } \\\\ & & { \\qquad \\odot \\mathbf { a } ^ { \\prime ( L - 1 ) } \\odot \\mathbf { a } ^ { \\prime ( L - 2 ) } \\odot \\cdots \\odot \\mathbf { a } ^ { \\prime ( l + 1 ) } \\odot \\mathbf { a } ^ { \\prime ( l ) } ( \\mathbf { a } ^ { ( l - 1 ) } ) ^ { T } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            123,
+            761,
+            179
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "If the regularization is too strong, the weights would be significantly suppressed as shown in Figure 5b. From (5), since the gradients are proportional to the product of the weights at later layers (whose magnitudes are typically much less than 1 for strong regularization), they are even more suppressed. ",
+        "bbox": [
+            178,
+            183,
+            820,
+            224
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In fact, the suppression is more severe than what we have deduced above. The factor $\\mathbf { a } ^ { ( l - 1 ) }$ in (5) could actually lead to further suppression to the gradients when the weights are very small, for the following reasons. First of all, we use ReLU as the activation function and it could be written as ",
+        "bbox": [
+            174,
+            232,
+            825,
+            275
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a33465c2118da619aaa7dfbf09be3ae8f9037f5a5f6a622207bf1d97f5a32359.jpg",
+        "text": "$$\n\\operatorname { R e L U } ( x ) = x \\ \\Theta ( x )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            281,
+            552,
+            299
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\Theta ( x )$ is the Heaviside step function. Using this, we could write ",
+        "bbox": [
+            174,
+            304,
+            632,
+            319
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/289eef2fbfc36e210ae6aaab0eb389fe2ba8e040837fff1ccaa55075049283a9.jpg",
+        "text": "$$\n\\mathbf { a } ^ { ( l - 1 ) } = \\left( \\mathbf { w } ^ { ( l - 1 ) } \\mathbf { a } ^ { ( l - 2 ) } \\right) \\odot \\Theta \\left( \\mathbf { w } ^ { ( l - 1 ) } \\mathbf { a } ^ { ( l - 2 ) } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            325,
+            650,
+            353
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Applying (7) recursively, we can see that $\\mathbf { a } ^ { ( l - 1 ) }$ is proportional to the product of the weights at previous layers. Again, when the weights are suppressed by strong regularization, $\\mathbf { a } ^ { ( l - 1 ) }$ would be suppressed correspondingly. Putting everything together, we can conclude that in the presence of strong regularization, the gradients are far more suppressed than the weights. ",
+        "bbox": [
+            174,
+            366,
+            825,
+            426
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Strictly speaking, the derivations above are valid only for fully-connected layers. For convolutional layers, the derivations are more complicated but similar. Our conclusions above would still be valid. ",
+        "bbox": [
+            174,
+            431,
+            820,
+            460
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Normalization Normalization techniques such as batch normalization (Ioffe & Szegedy, 2015) and weight normalization (Salimans & Kingma, 2016) can be possible approaches to prevent the $\\mathcal { L }$ gradients from diminishing quickly. However, it has been shown that L2 regularization has no regularizing effect when combined with normalization but only influences on the effective learning rate, resulting in good performance (van Laarhoven, 2017). In other words, the normalization techniques do not really simplify the solution as the decrease of parameter magnitude is canceled by normalization. This does not meet our goal, which is to heavily simplify solutions to reduce over-fitting, so we propose an approach that meets our goal. ",
+        "bbox": [
+            173,
+            474,
+            825,
+            588
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 OUR PROPOSED APPROACH: DELAYED STRONG REGULARIZATION",
+        "text_level": 1,
+        "bbox": [
+            174,
+            603,
+            678,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since we have seen that stronger regularization can result in better performance in Figure 1, we propose a method that is able to accommodate strong regularization. Specifically, we introduce a time-dependent regularization strength, $\\lambda _ { t }$ , to the equation (2), and it is defined as ",
+        "bbox": [
+            174,
+            630,
+            825,
+            672
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/74fd3a148ebcf757b309d9dbfd7163948baa511559959b9d6ff7452cb64ec586.jpg",
+        "text": "$$\n\\lambda _ { t } = { \\left\\{ \\begin{array} { l l } { 0 } & { { \\mathrm { i f ~ e p o c h } } ( t ) < \\gamma } \\\\ { \\lambda } & { { \\mathrm { o t h e r w i s e } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            679,
+            581,
+            714
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where epoch $( t )$ gets the epoch number of the time step $t$ , and $\\gamma$ is a hyper-parameter that is set through cross-validation. The formula means that we do not impose any regularization until $\\gamma ^ { \\mathrm { t h } }$ epoch, and then impose the strong regularization in each training step. The underlying hypothesis is that once the model follows a good learning path, i.e., the gradient from $\\mathcal { L }$ is big enough, it won’t easily change its direction because of the steep slope, and thus, it can learn without failure. We empirically verify our hypothesis in the experiment section. The hyper-parameter $\\gamma$ is relatively easy to set because the models often follow the good path in a couple of epochs, and once they follow such path, learning does not fail. We recommend using $2 \\leq \\gamma \\leq 2 0$ . Please note that our approach is different from imposing a slightly weaker regularization throughout the whole training. The reduced amount by not skipping regularization for the first few epochs is negligible compared to the total reduced amount by regularization. In addition, we empirically show that our approach can achieve a much higher sparsity than the baseline in the parameter space. ",
+        "bbox": [
+            173,
+            720,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The proposed method is easy to implement, and the hyper-parameter is easy to set. Also, the method is very close to the traditional regularization method so that it inherits the traditional one’s good performance for non-strong regularization while it also achieves strong regularization. Although the method is very simple, we found that it shows the best accuracy among the approaches we tried in our preliminary experiments while it is the simplest. The preliminary experiments are further discussed in Appendix B. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proximal gradient algorithm for L1 regularizer Meanwhile, since L1 norm is not differentiable at zero, we employ the proximal gradient algorithm (Parikh et al., 2014), which enables us to obtain proper sparsity (i.e., guaranteed convergence) for non-smooth regularizers. We use the following update formulae: ",
+        "bbox": [
+            174,
+            178,
+            823,
+            233
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/eb69a734cd418d697267592f9376b64d27e0804b1eb90a66c2814a8fe94097ef.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\mathbf { w } _ { i } ^ { ( t ^ { \\prime } ) } = \\mathbf { w } _ { i } ^ { ( t ) } - \\alpha \\ \\frac { \\partial \\mathcal { L } } { \\partial \\mathbf { w } _ { i } } \\bigg | _ { \\mathbf { w } _ { i } = \\mathbf { w } _ { i } ^ { ( t ) } } } \\\\ & { \\mathbf { w } _ { i } ^ { ( t + 1 ) } = \\mathrm { p r o x } _ { \\alpha \\lambda \\Omega } ( \\mathbf { w } _ { i } ^ { ( t ^ { \\prime } ) } ) = S ( \\mathbf { w } _ { i } ^ { ( t ^ { \\prime } ) } , \\alpha \\lambda ) } \\\\ & { S ( a , z ) = \\left\\{ \\begin{array} { l l } { a - z } & { \\mathrm { i f ~ } a > z } \\\\ { a + z } & { \\mathrm { i f ~ } a < - z } \\\\ { 0 } & { \\mathrm { o t h e r w i s e } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            236,
+            642,
+            352
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $S$ is a soft-thresholding operator. Basically, the algorithm assigns zero to a parameter if its next updated value is smaller than $\\alpha \\lambda$ . In other cases, it just decreases the magnitude of the parameter as usual. ",
+        "bbox": [
+            174,
+            358,
+            823,
+            401
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            424,
+            326,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate the effectiveness of our proposed method with popular architectures, AlexNet (Krizhevsky et al., 2012) and VGG-16 (Simonyan & Zisserman, 2014) on the public data sets CIFAR-10 and CIFAR-100 (Krizhevsky & Hinton, 2009). Then, we employ variations of VGG on another public data set SVHN (Netzer et al., 2011), in order to see the effect of the number of hidden layers on the tolerance level. Please note that we do not employ architectures that contain normalization techniques such as batch normalization (Ioffe & Szegedy, 2015), for the reason described in Section 2.2. The data set statistics are described in Table 1. VGG-11 and VGG-19 for SVHN contain 9.8 and 20.6 millions of parameters. ",
+        "bbox": [
+            173,
+            457,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/5286ed5bb51932800a97754b8fa10234888faf456846cc9c84e3135a162ebf82.jpg",
+        "table_caption": [
+            "Table 1: Data set statistics for CIFAR-10 and CIFAR-100. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Data Set</td><td>Image Resolution</td><td>Classes</td><td>Training Images per Class</td><td>Test Images per Class</td><td>AlexNet Parameters</td><td>VGG-16 Parameters</td></tr><tr><td>CIFAR-10</td><td>32×32</td><td>10</td><td>5000</td><td>1000</td><td>2.6M</td><td>15.2M</td></tr><tr><td>CIFAR-100</td><td>32×32</td><td>100</td><td>500</td><td>100</td><td>2.6M</td><td>15.3M</td></tr><tr><td>SVHN</td><td>32×32</td><td>10</td><td>7325.7 (avg.)</td><td>2603.2 (avg.)</td><td>1</td><td>15.2M</td></tr></table>",
+        "bbox": [
+            173,
+            616,
+            843,
+            691
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Regularization is applied to all network parameters except bias terms. We use PyTorch3 framework for all experiments, and we use its official computer vision library4 for the implementations of the networks. In order to accommodate the data sets, we made some modifications to the networks. The kernel size of AlexNet’s max-pooling layers is changed from 3 to 2, and the first convolution layer’s padding size is changed from 2 to 5. All of its fully connected layers are modified to have 256 neurons. For VGG, we modified the fully connected layers to have 512 neurons. The output layers of both networks have 10 neurons for CIFAR-10 and SVHN, and 100 neurons for CIFAR100. The networks are learned by stochastic gradient descent algorithm with momentum of 0.9. The parameters are initialized according to He et al. (2015). The batch size is set to 128, and the initial learning rate is set to 0.05 and decays by a factor of 2 every 30 epochs during the whole 300-epoch training. In all experiments, we set $\\gamma = 5$ . We did not find significantly different results for $2 \\leq \\gamma \\leq 2 0$ . Please note that we still use drop out layers (with drop probability 0.5) and preprocess training data5 in order to report the extra performance boost on top of common regularization techniques. ",
+        "bbox": [
+            173,
+            713,
+            825,
+            881
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/259bf6e95da2c0d6e74b0d8654c329a5fa9fcab0236570e73a67e1eb051f4289.jpg",
+        "image_caption": [
+            "Figure 3: Accuracies obtained by VGG-16 with L1 and L2 regularization on CIFAR-100 (a,b,c) and CIFAR-10 (d,e,f). A green dotted horizontal line is an accuracy obtained by a model without L1/L2 regularization (but with dropout). Accuracy for different sparsity is shown in (c) and (f). The error bars indicate $9 5 \\%$ confidence interval. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            813,
+            393
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            492,
+            823,
+            521
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "AlexNet and VGG-16 are experimented for different regularization methods (L1 and L2) and different data sets (CIFAR-10 and CIFAR-100), yielding 8 combinations of experiment sets. Then, VGG-11, VGG-16, and VGG-19 are experimented for L1 and L2 regularization methods on SVHN, yielding 6 experiment sets. For each experiment set, we set the baseline method as the one with well-tuned L1 or L2 regularization but without our time-dependent regularization strength. For each regularization, we try more than 10 different values of $\\lambda$ , and for each value, we report average accuracy of three independent runs and report $9 5 \\%$ confidence interval. We perform statistical significance test (t-test) for the improvement over the baseline method and report the p-value. We also report sparsity of each trained model, which is the proportion of the number of zero-valued parameters to the number of all parameters. Please note that we mean the sparsity by the one actually derived by the models, not by pruning parameters with threshold after training. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1 EXPERIMENT RESULTS ON CIFAR-10 AND CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            700,
+            601,
+            715
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The experiment results by VGG-16 are depicted in Figure 3. As we investigated in Section 2.2, the baseline method suddenly fails beyond certain values of tolerance level. However, our proposed method does not fail for higher values of $\\lambda$ . As a result, our model can achieve higher accuracy as well as higher sparsity. In practice, L2 regularization is used more often than L1 regularization due to its superior performance, and this is true for our VGG-16 experiments too. Using L2 regularization, our model improves the model without L1 or L2 regularization but with dropout, by $1 4 . 4 \\%$ in accuracy, which is about $24 \\%$ of error rate improvement. Tuning L2 regularization parameter is difficult as the curves have somewhat sharp peak, but our proposed method ease the problem to some extent by preventing the sharp drop. Our L1 regularizer obtains much better sparsity for the similar level of accuracy (Figure 3c), which means that strong regularization plays an important role in compressing neural networks. The improvement is more prominent on CIFAR-100 than on ",
+        "bbox": [
+            174,
+            728,
+            825,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/a30578c48bb27c6b33f2220e09936540058b7c489b5e455745c29530a08ff6cd.jpg",
+        "image_caption": [
+            "Figure 4: Accuracies obtained by AlexNet with L1 and L2 regularization on CIFAR-100 (a,b,c) and CIFAR-10 (d,e,f). A green dotted horizontal line is an accuracy obtained by a model without L1/L2 regularization (but with dropout). Accuracy for different sparsity is shown in (c) and (f). The error bars indicate $9 5 \\%$ confidence interval. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            815,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10, and we think this is because over-fitting can more likely occur on CIFAR-100 as there are less images per class than on CIFAR-10. ",
+        "bbox": [
+            174,
+            518,
+            823,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The experiment results by AlexNet are depicted in Figure 4. Again, our proposed method achieves higher accuracy and sparsity in general. Unlike VGG-16, we obtain more improvement over baseline with L1 regularization than with L2 regularization. In addition, the curves make sharper peaks than those by VGG-16 especially for the sparsity regularizer (L1). ",
+        "bbox": [
+            174,
+            554,
+            825,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, our proposed method often obtains higher accuracy even when the baseline does not fail on CIFAR-10, and this is only prominent when the regularization strength is relatively strong (better shown in Figure 3f, 4c, 4f). This may be because avoiding strong regularization in the early stage of training can help the model to explore more spaces freely, and the better exploration results in finding superior local optima. ",
+        "bbox": [
+            174,
+            617,
+            825,
+            688
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The overall experiment results are shown in Table 2. It shows that there is more performance improvement by L1/L2 regularization on VGG-16 than on AlexNet, which is reasonable since VGG-16 contains about 6 times more parameters so that it is more prone to over-fitting. Our proposed model always improves the baselines by up to $3 . 8 9 \\%$ , except AlexNet with L1 regularization on CIFAR10, and most (6 out of 7) improvements are statistically significant $( \\mathrm { p } ; 0 . 0 5 )$ . Our L1 regularization models always obtain higher sparsity with compression rate up to $4 . 2 \\times$ than baselines, meaning that our model is promising for compressing neural networks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also show in Figure 5 how gradients and weights change when our method and the baseline are applied. We hypothesized that if the model reaches an “active learning” phase with an elevated gradient amount, it does not suffer from vanishing gradients any more even when strong regularization is enforced. The Figure 5a shows that our model indeed reaches there by skipping strong regularization for the first five epochs, and and it keeps learning even after strong regularization is enforced. In Figure 5b, although the same strong regularization is enforced since epoch 5, the magnitude of weights in our model stops decreasing around epoch 20, while that in baseline (green dotted line) keeps decreasing towards zero. This means that our model can cope with strong regularization, and it maintains its equilibrium between gradients from $\\mathcal { L }$ and those from regularization. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/c7366927cfbb55aaa41acb3a3abcc45533406471338dbd9be5dac8222ccc9d7b.jpg",
+        "table_caption": [
+            "Table 2: Overall experiment results. The $9 5 \\%$ confidence interval is reported after $\\pm$ symbol. The improvement is calculated by comparing with baseline methods. Compression rate is calculated by how much the regularization reduces the number of non-zero-valued parameters while having an accuracy similar to L1 baseline. Note that when no L1/L2 regularization is imposed, dropout is still employed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"3\">CIFAR-100</td><td colspan=\"2\">CIFAR-10</td></tr><tr><td></td><td>Sparsity</td><td>Acc. (%)</td><td>Sparsity</td><td>Acc. (%)</td></tr><tr><td rowspan=\"9\">VGG-16</td><td>No L1/L2</td><td>0</td><td>62.08 ± 0.81</td><td>0</td><td>90.80± 0.23</td></tr><tr><td>L2baseline</td><td>0</td><td>69.16± 0.46</td><td>0</td><td>92.42 ± 0.16</td></tr><tr><td>L2 ours</td><td>0</td><td>71.01 ± 0.33</td><td>0</td><td>92.60 ± 0.16</td></tr><tr><td>Acc.improvement</td><td>1</td><td>+2.67% (p=0.002)</td><td>1</td><td>+0.19% (p=0.103)</td></tr><tr><td>L1baseline</td><td>0.269</td><td>66.94 ± 0.24</td><td>0.808</td><td>91.29± 0.16</td></tr><tr><td>L1 ours</td><td>0.303</td><td>67.55 ± 0.12</td><td>0.845</td><td>91.55 ± 0.10</td></tr><tr><td>Acc.improvement</td><td></td><td>+0.91% (p=0.011)</td><td></td><td>+0.28% (p=0.037)</td></tr><tr><td>Li ours (sparse) Compression rate over</td><td>0.697</td><td>67.06± 0.62</td><td>0.926</td><td>91.38± 0.05</td></tr><tr><td>L1 baseline</td><td>2.4×</td><td></td><td>2.6×</td><td></td></tr><tr><td rowspan=\"8\">AlexNet</td><td>No L1/L2</td><td>0</td><td>43.09±0.25</td><td>0</td><td>75.05± 0.20</td></tr><tr><td>L2 baseline</td><td>0</td><td>46.91 ± 0.15</td><td>0</td><td>78.66 ± 0.17</td></tr><tr><td>L2 ours</td><td>0</td><td>47.64 ± 0.33</td><td>0</td><td>78.65 ± 0.29</td></tr><tr><td>Acc.improvement</td><td>-</td><td>+1.56% (p=0.017)</td><td>1</td><td>-0.01%</td></tr><tr><td>L1baseline</td><td>0.219</td><td>45.70± 0.10</td><td>0.766</td><td>76.87 ± 0.24</td></tr><tr><td>L1 ours</td><td>0.632</td><td>47.48 ± 0.29</td><td>0.794</td><td>77.63 ± 0.34</td></tr><tr><td>Acc.improvement</td><td>1</td><td>+3.89% (p=0.002)</td><td>1</td><td>+0.99% (p=0.013)</td></tr><tr><td>Lf ours (sparse)</td><td>0.814</td><td>45.77±0.32</td><td>0.877</td><td>76.90± 0.227</td></tr><tr><td></td><td>Compression rate over L1 baseline</td><td>4.2×</td><td></td><td>1.9×</td><td></td></tr></table>",
+        "bbox": [
+            173,
+            241,
+            854,
+            551
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/893965a3fec3eb65e2bc6c4d473e0d66cb82d0d2558b411f664e2ae45ed153dd.jpg",
+        "image_caption": [
+            "Figure 5: Experiment results by L2 regularization with VGG-16 on CIFAR-100. The results are from baseline method unless it is labeled as “ours”. Our proposed Delayed Strong Regularization does not fail in learning. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            674,
+            805,
+            814
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/880d6f907b7051ce27d5933c2ac10e7ae3be299a3c0ffb893254f286ca5d1f87.jpg",
+        "image_caption": [
+            "Figure 6: Accuracies obtained by variations of VGG with L2 regularization on SVHN. A green dotted horizontal line is an accuracy obtained by a model without L2 regularization (but with dropout). The error bars indicate $9 5 \\%$ confidence interval. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            102,
+            815,
+            243
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/6d9d94c2799bf220f6ca4e7038e0b179af548222e73317f39173575b73d45587.jpg",
+        "table_caption": [
+            "Table 3: Experiment results on SVHN. The improvement is calculated by comparing with baseline methods. Note that when no L1/L2 regularization is imposed, dropout is still employed. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td colspan=\"2\">VGG-11</td><td colspan=\"2\">VGG-16</td><td colspan=\"2\">VGG-19</td></tr><tr><td>Sparsity</td><td>Acc. (%)</td><td>Sparsity</td><td>Acc. (%)</td><td>Sparsity</td><td>Acc. (%)</td></tr><tr><td>No L1/L2</td><td>0</td><td>94.27 ± 0.13</td><td>0</td><td>95.10± 0.22</td><td>0</td><td>95.20± 0.10</td></tr><tr><td>L2 baseline</td><td>0</td><td>94.82 ± 0.02</td><td>0</td><td>95.38± 0.10</td><td>0</td><td>95.45± 0.14</td></tr><tr><td>L2 ours</td><td>0</td><td>94.84 ± 0.04</td><td>0</td><td>95.53 ± 0.07</td><td>0</td><td>95.74 ± 0.07</td></tr><tr><td>Acc.improvement</td><td>-</td><td>+0.02% (p=0.200)</td><td>-</td><td>+0.16% (p=0.047)</td><td>-</td><td>+0.30% (p=0.019)</td></tr><tr><td>L1 baseline</td><td>0.519</td><td>94.68±0.08</td><td>0.450</td><td>95.34 ± 0.11</td><td>0.122</td><td>95.37 ± 0.11</td></tr><tr><td>Ll ours</td><td>0.621</td><td>94.78 ± 0.07</td><td>0.795</td><td>95.38 ± 0.11</td><td>0.518</td><td>95.50 ± 0.15</td></tr><tr><td>Acc.improvement</td><td></td><td>+0.11% (p=0.056)</td><td>=</td><td>+0.04% (p=0.324)</td><td>=</td><td>+0.13% (p=0.180)</td></tr><tr><td>L1 ours (sparse) Compression rate over</td><td>0.845</td><td>94.710.01</td><td>70.795</td><td>95.38±0.11</td><td>0.911</td><td>95.410.07</td></tr><tr><td>L1 baseline</td><td>3.1×</td><td></td><td>2.7×</td><td></td><td>9.9×</td><td></td></tr></table>",
+        "bbox": [
+            187,
+            358,
+            808,
+            484
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "3.2 EXPERIMENT RESULTS ON SVHN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            450,
+            531
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The analysis in Section 2.2 implies that the number of hidden layers would affect the tolerance level when strong regularization is imposed. That is, if there are more hidden layers in the neural network architecture, the learning will fail more easily by strong regularization. In order to check the hypothesis empirically, we employ variations of the VGG architecture, i.e., VGG-11, VGG-16, and VGG-19, which contain 11, 16, and 19 hidden layers, respectively. We experiment them on the SVHN data set. ",
+        "bbox": [
+            173,
+            542,
+            825,
+            626
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The results by L2 regularization are depicted in Figure 6. As shown, the peak of our method’s performance is formed around $\\lambda = 1 \\times \\bar { 1 } 0 ^ { - 3 }$ . As more hidden layers are added to the network, the tolerance level where the performance suddenly drops by the baseline is shifted to left, as hypothesized by our analysis. The results by L1 regularization are in Appendix A, and it is shown that VGG-19 more easily fails as the parameters become more sparse. The overall experiment results are shown in Table 3. As the method without L1/L2 regularization already performs well on this data set and there are relatively many training images per class, the improvement by L1/L2 regularization is not big. Our method still outperforms the baseline in all experiments (6 out of 6), but the improvement is less statistically significant compared to CIFAR-10 and CIFAR-100 data sets. The compression rate is especially good for VGG-19 mainly because its tolerance level is low so that the baseline can only achieve low sparsity. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            808,
+            344,
+            824
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The related work is partially covered in Section 1, and we extend other related work here. It has been shown that L2 regularization is important for training DNNs (Krizhevsky et al., 2012; Deng et al., 2013). Although there has been a new regularization method such as dropout, L2 regularization has been shown to reduce the test error effectively when combined with dropout (Srivastava et al., 2014). Meanwhile, L1 regularization has also been used often in order to obtain sparse solutions. To reduce computation and power consumption, L1 regularization and its variations such as group sparsity regularization has been promising for deep neural networks (Wen et al., 2016; Scardapane et al., 2017; Yoon & Hwang, 2017). However, for both L1 and L2 regularization, the phenomenon that learning fails with strong regularization has not been emphasized previously. Bergstra & Bengio (2012) showed that tuning hyper-parameters such as L2 regularization strength can be effectively done through random search instead of grid search, but they did not study how and why learning fails or how strong regularization can be successfully achieved. Yosinski et al. (2015) visualized activations to understand deep neural networks and showed that strong L2 regularization fails to learn. However, it was still not shown how and why learning fails and how strong regularization can be achieved. To the best of our knowledge, there is no existing work that is dedicated to studying the phenomenon that learning fails with strong regularization and to proposing a method that can avoid the failure. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            256
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            284,
+            310,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we studied the problem of achieving strong regularization for deep neural networks. Strong regularization with gradient descent algorithm easily fails for deep neural networks, but few work addressed this phenomenon in detail. We provided investigation and analysis of the phenomenon, and we found that there is a strict tolerance level of regularization strength. To avoid this problem, we proposed a novel but simple method: Delayed Strong Regularization. We performed experiments with fine tuning of regularization strength. Evaluation results show that (1) our model successfully achieves strong regularization on deep neural networks, verifying our hypothesis that the model will keep learning once it reaches an “active learning” phase, (2) with strong regularization, our model obtains higher accuracy and sparsity, (3) the number of hidden layers in neural networks affects the tolerance level, and (4) L1/L2 regularization is difficult to tune, but it can yield great performance boost when tuned well. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "There are limitations in this work. Our proposed method can be especially useful when strong regularization is desired. For example, deep learning projects that cannot afford a huge labeled data set can benefit from our method. However, strong regularization may not be necessary in some other cases where the large labeled data set is available or the networks do not contain many parameters. In addition, our experiments were not performed on a bigger data set such as ImageNet data set. We need to fine-tune the models with different regularization parameters, and we also need multiple training sessions of each model to obtain confidence interval. For example, the experiment results in Figure 3 and 4 include 750 training sessions in total. This is something we cannot afford with ImageNet data set, which requires several weeks of training for EACH session (unless we have GPU clusters). Our approach cannot be applied to architectures containing normalization techniques for the reason in Section 2.2. We actually tried to intentionally exclude normalization part from Residual Networks (He et al., 2016) and train the model to see if we can apply our method to non-normalized Residual Networks. However, we could not control the exploding gradients caused by the exclusion of normalization. ",
+        "bbox": [
+            174,
+            479,
+            825,
+            672
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our work can be further extended in several ways. Since our model can achieve strong regularization, it will be interesting to see how the strongly regularized model performs if combined with pruning-related methods (Han et al., 2015; 2016). We applied our approach to only L1 and L2 regularizers, but applying it to other regularizers such as group sparsity regularizers will be promising as they are often employed for DNNs to compress networks. Lastly, our proposed Delayed Strong Regularization is very simple, so one can easily extend it to more complicated methods. All these directions are left as our future work. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            776
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            804,
+            285,
+            820
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James Bergstra and Yoshua Bengio. Random search for hyper-parameter optimization. Journal of Machine Learning Research, 13(Feb):281–305, 2012. ",
+        "bbox": [
+            176,
+            832,
+            823,
+            859
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Li Deng, Geoffrey Hinton, and Brian Kingsbury. New types of deep neural network learning for speech recognition and related applications: An overview. In Acoustics, Speech and Signal Processing (ICASSP), 2013 IEEE International Conference on, pp. 8599–8603. IEEE, 2013. ",
+        "bbox": [
+            174,
+            881,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, John Tran, and William Dally. Learning both weights and connections for efficient neural network. In Advances in Neural Information Processing Systems, pp. 1135–1143, 2015. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Song Han, Jeff Pool, Sharan Narang, Huizi Mao, Shijian Tang, Erich Elsen, Bryan Catanzaro, John Tran, and William J Dally. Dsd: Regularizing deep neural networks with dense-sparse-dense training flow. arXiv preprint arXiv:1607.04381, 2016. ",
+        "bbox": [
+            178,
+            154,
+            821,
+            196
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Delving deep into rectifiers: Surpassing human-level performance on imagenet classification. In Proceedings of the IEEE international conference on computer vision, pp. 1026–1034, 2015. ",
+        "bbox": [
+            176,
+            204,
+            821,
+            247
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            176,
+            255,
+            821,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Geoffrey Hinton, Li Deng, Dong Yu, George E Dahl, Abdel-rahman Mohamed, Navdeep Jaitly, Andrew Senior, Vincent Vanhoucke, Patrick Nguyen, Tara N Sainath, et al. Deep neural networks for acoustic modeling in speech recognition: The shared views of four research groups. IEEE Signal Processing Magazine, 29(6):82–97, 2012. ",
+        "bbox": [
+            174,
+            305,
+            826,
+            363
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning, pp. 448–456, 2015. ",
+        "bbox": [
+            174,
+            371,
+            825,
+            412
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky and Geoffrey Hinton. Learning multiple layers of features from tiny images. 2009. ",
+        "bbox": [
+            171,
+            420,
+            821,
+            436
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            176,
+            444,
+            825,
+            486
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yuval Netzer, Tao Wang, Adam Coates, Alessandro Bissacco, Bo Wu, and Andrew Y Ng. Reading digits in natural images with unsupervised feature learning. In NIPS workshop on deep learning and unsupervised feature learning, volume 2011, pp. 5, 2011. ",
+        "bbox": [
+            174,
+            494,
+            825,
+            537
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Neal Parikh, Stephen Boyd, et al. Proximal algorithms. Foundations and Trends $\\textsuperscript { \\textregistered }$ in Optimization, 1(3):127–239, 2014. ",
+        "bbox": [
+            174,
+            545,
+            823,
+            574
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kristiaan Pelckmans, Johan AK Suykens, and Bart De Moor. Morozov, ivanov and tikhonov regularization based ls-svms. In International Conference on Neural Information Processing, pp. 1216–1222. Springer, 2004. ",
+        "bbox": [
+            174,
+            582,
+            825,
+            625
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tim Salimans and Diederik P Kingma. Weight normalization: A simple reparameterization to accelerate training of deep neural networks. In Advances in Neural Information Processing Systems, pp. 901–909, 2016. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            675
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Simone Scardapane, Danilo Comminiello, Amir Hussain, and Aurelio Uncini. Group sparse regularization for deep neural networks. Neurocomputing, 241:81–89, 2017. ",
+        "bbox": [
+            173,
+            683,
+            821,
+            713
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            174,
+            719,
+            821,
+            750
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Geoffrey E Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: a simple way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):1929–1958, 2014. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            800
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Robert Tibshirani. Regression shrinkage and selection via the lasso. Journal of the Royal Statistical Society. Series B (Methodological), pp. 267–288, 1996. ",
+        "bbox": [
+            173,
+            808,
+            823,
+            837
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Twan van Laarhoven. L2 regularization versus batch and weight normalization. arXiv preprint arXiv:1706.05350, 2017. ",
+        "bbox": [
+            173,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Wei Wen, Chunpeng Wu, Yandan Wang, Yiran Chen, and Hai Li. Learning structured sparsity in deep neural networks. In Advances in Neural Information Processing Systems, pp. 2074–2082, 2016. ",
+        "bbox": [
+            176,
+            881,
+            825,
+            922
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/0bab4650ce56fbb965b1d1511b7a979debb8d3f8bd9d5c1ad4b95d5a14cde7ff.jpg",
+        "image_caption": [
+            "Figure 7: Accuracies obtained by variations of VGG with L1 regularization on SVHN. A green dotted horizontal line is an accuracy obtained by a model without L1 regularization (but with dropout). Accuracy for different sparsity is shown in (d), (e), and (f). The error bars indicate $9 5 \\%$ confidence interval. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            103,
+            815,
+            390
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jaehong Yoon and Sung Ju Hwang. Combined group and exclusive sparsity for deep neural networks. In International Conference on Machine Learning, pp. 3958–3966, 2017. ",
+        "bbox": [
+            173,
+            483,
+            820,
+            512
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jason Yosinski, Jeff Clune, Anh Nguyen, Thomas Fuchs, and Hod Lipson. Understanding neural networks through deep visualization. arXiv preprint arXiv:1506.06579, 2015. ",
+        "bbox": [
+            174,
+            520,
+            820,
+            549
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Appendices ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            588,
+            343,
+            616
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A EXPERIMENT RESULTS ON SVHN BY L1 REGULARIZER ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            638,
+            676,
+            655
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "To empirically check the effect of the number of hidden layers on the tolerance level, we experimented variations of VGG on SVHN, and we showed the results by L2 regularizer in Section 3.2. Here, we show the results by L1 regularizer in Figure 7. As more hidden layers are included to the network, the tolerance level where the baseline method suddenly fails is shifted to left. Such pattern in baseline method is more clearly shown in the accuracy vs. sparsity plots. VGG-19 fails to learn even when it loses only $27 \\%$ of its parameters, whereas VGG-11 can still learn after losing $84 \\%$ of its parameters. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            767
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B PRELIMINARY EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            787,
+            450,
+            804
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The reason why we proposed a very simple method is that it is effective while it is simple to implement. The only additional hyper-parameter, which is the number of initial epochs to skip regularization, is also not difficult to set. We think that the proposed method is very similar to the traditional regularization method so that it inherits the traditional one’s good performance for non-strong regularization while it also achieves strong regularization. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            888
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We actually tried a couple more approaches other than the proposed one in our preliminary experiments. We found that the proposed one shows the best accuracy among the approaches we tried while it is the simplest. For example, we tried an approach that can be regarded as a warm-start strategy. It starts with the regularization parameter $\\lambda _ { t } = 0$ , and then it gradually increases $\\lambda _ { t }$ to $\\lambda$ for $\\gamma$ epochs, where $\\gamma > = 0$ and it is empirically set. We found that it can achieve strong regularization, but its best accuracy is similar to or slightly lower than that of our proposed approach. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            160
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We also tried a method that is similar to Ivanov regularization (Pelckmans et al., 2004). In this method, the regularization term is applied only when the L1 norm of the weights is greater than a certain threshold. To enforce strong regularization, we set $\\lambda$ just above the tolerance level that is found by the baseline method. However, this method did not accomplish any learning. The reason is that, to reach the level of L1 norm that is low enough, the model needs to go through the strong regularization for the first few epochs, and the neurons already lose its learning ability during this period like the baseline method. If we set $\\lambda$ below the tolerance level, it cannot reach the desired L1 norm without strong regularization, and thus the performance is inferior to our proposed method. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            279
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Meanwhile, an approach that applies strong regularization first and then continuously reduces the regularization strength is used in sparse learning for convex optimization. This approach is opposite to our approach in that ours avoids strong regularization for the first few epochs and then apply strong regularization afterwards. We performed a simple experiment with VGG-16 on CIFAR-100 to see if the approach can perform well for deep neural networks. We set the initial regularization parameter $\\lambda = \\overset { \\cdot } { 2 } \\times 1 0 ^ { - 3 }$ and $\\lambda = 6 \\times 1 0 ^ { - 5 }$ for L2 and L1 regularization, respectively, which are just above the ”tolerance level”. Then, we continuously reduced $\\lambda _ { t }$ to zero throughout the training session. The trained models didn’t show any improvement over ”random guess”, which means that they were not able to learn. Once the strong regularization is enforced in the beginning, the magnitudes of weights decrease quickly. This in turn drives the magnitudes of gradients to diminish exponentially in deep neural networks as explained in Section 2.2, and thus, the model loses its ability to learn after a short period of strong regularization. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            452
+        ],
+        "page_idx": 12
+    }
+]

parse/train/HOFxeCutxZR/HOFxeCutxZR_content_list.json

@@ -0,0 +1,1694 @@
+[
+    {
+        "type": "text",
+        "text": "ENJOY YOUR EDITING: CONTROLLABLE GANS FOR IMAGE EDITING VIA LATENT SPACE NAVIGATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Peiye Zhuang, Oluwasanmi Koyejo, Alexander G. Schwing University of Illinois at Urbana-Champaign {peiye, sanmi, aschwing}@illinois.edu ",
+        "bbox": [
+            183,
+            170,
+            594,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            250,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Controllable semantic image editing enables a user to change entire image attributes with a few clicks, e.g., gradually making a summer scene look like it was taken in winter. Classic approaches for this task use a Generative Adversarial Net (GAN) to learn a latent space and suitable latent-space transformations. However, current approaches often suffer from attribute edits that are entangled, global image identity changes, and diminished photo-realism. To address these concerns, we learn multiple attribute transformations simultaneously, integrate attribute regression into the training of transformation functions, and apply a content loss and an adversarial loss that encourages the maintenance of image identity and photo-realism. We propose quantitative evaluation strategies for measuring controllable editing performance, unlike prior work, which primarily focuses on qualitative evaluation. Our model permits better control for both single- and multipleattribute editing while preserving image identity and realism during transformation. We provide empirical results for both natural and synthetic images, highlighting that our model achieves state-of-the-art performance for targeted image manipulation. ",
+        "bbox": [
+            233,
+            282,
+            764,
+            502
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            336,
+            539
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Semantic image editing is the task of transforming a source image to a target image while modifying desired semantic attributes, e.g., to make an image taken during summer look like it was captured in winter. The ability to semantically edit images is useful for various real-world tasks, including artistic visualization, design, photo enhancement, and targeted data augmentation. To this end, semantic image editing has two primary goals: (i) providing continuous manipulation of multiple attributes simultaneously and (ii) maintaining the original image’s identity as much as possible while ensuring photo-realism. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            645
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Existing GAN-based approaches for semantic image editing can be categorized roughly into two groups: (i) image-space editing methods directly transform one image to another across domains (Choi et al., 2018; 2020; Isola et al., 2017; Lee et al., 2020; Wu et al., 2019; Zhu et al., 2017a;b), usually using variants of generative adversarial nets (GANs) (Goodfellow et al., 2014). These approaches often have high computational cost, and they primarily focus on binary attribute (on/off) changes, rather than providing continuous attribute editing abilities. (ii) latent-space editing methods focus on discovering latent variable manipulations that permit continuous semantic image edits. The chosen latent space is most often the latent space of GANs. Both unsupervised and (self-)supervised latent space editing methods have been proposed. Unsupervised latent-space editing methods (Hark ¨ onen et al., 2020; Voynov & Babenko, 2020) are often less effective at pro- ¨ viding semantically meaningful directions and all too often change image identity during an edit. Current (self-)supervised methods (Jahanian et al., 2019; Plumerault et al., 2020) are limited to geometric edits such as rotation and scale. To our knowledge, only one supervised approach has been proposed (Shen et al., 2019) – developed to discover semantic latent-space directions for binary attributes. As we show, this method suffers from entangled attributes and often does not preserve image identity during manipulation. ",
+        "bbox": [
+            174,
+            654,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Contributions. We propose a latent-space editing framework for semantic image manipulation that fulfills the aforementioned primary goals. Specifically, we use a GAN and employ a joint sampling strategy trained to edit multiple attributes simultaneously. To disentangle attribute transformations in the latent space of GANs, we integrate a regressor to predict the attributes that an image exhibits. The regressor also permits precise control of the manipulation degree and is easily extended to multiple attributes simultaneously. In addition, we incorporate a perceptual loss (Li et al., 2019) and an adversarial loss that helps preserve image identity and photo-realism during manipulation. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/fb07bc41864ba9b101d2f40fa0c12c3111aac85a77e90532d3aaba7be5d481e0.jpg",
+        "image_caption": [
+            "Figure 1: Real image manipulation on scene (top two rows, photo from Flickr) and face (bottom two rows, unseen image from CelebA-HQ) using pretrained StyleGAN2 (Karras et al., 2019b): We reconstruct the real images (col.1) by finding a latent vector with the best inversion result (col.2) on StyleGAN2 (Abdal et al., 2019). After that, we transform the latent vectors for single- and multipleattribute manipulations (col.3-6). Note that unlike ours, the baseline method (Shen et al., 2019) either changes image identity or confounds semantic properties, or both. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            89,
+            812,
+            387
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            496,
+            825,
+            553
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We compare our method to several popular frameworks, from existing image-to-image translation methods (Choi et al., 2020; Wu et al., 2019; Zhu et al., 2017a) to latent space transformation-based approaches (Shen et al., 2019; Voynov & Babenko, 2020). We mention that prior work primarily uses qualitative evaluation like the one in Fig. 1. In contrast, we propose a quantitative evaluation to measure controllability. Both qualitative and quantitative results provide evidence that our approach outperforms prior work in terms of quality of the semantic image manipulation while maintaining image identity. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            657
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            675,
+            341,
+            690
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Generative Adversarial Networks (GANs) (Goodfellow et al., 2014) have significantly improved realistic image generation in recent years (Brock et al., 2018; Jolicoeur-Martineau, 2019; Karras et al., 2017; 2019a;b; Park et al., 2019; Zhang et al., 2018). For this, a GAN formulates a 2-player non-cooperative game between two deep nets: (i) a generator that produces an image given a random noise vector in the latent space, sampled from a known prior distribution, usually a normal or a uniform distribution; (ii) a discriminator whose input is both synthetic and real data, which is to be differentiated. ",
+        "bbox": [
+            174,
+            708,
+            825,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Semantic image editing seeks to automate image manipulation of semantics. Encouraged by the success of deep nets, recent works have applied deep learning methods for semantic image editing tasks such as style transfer (Li et al., 2017; Luan et al., 2017), image-to-image translation (Choi et al., 2018; 2020; Isola et al., 2017; Lee et al., 2020; Wang et al., 2018; Wu et al., 2019; Zhu et al., 2017a) and discovering semantically meaningful directions in a GAN latent space (Hark ¨ onen et al., 2020; ¨ Jahanian et al., 2019; Plumerault et al., 2020; Shen et al., 2019; Voynov & Babenko, 2020). Note that our task is an extended version of semantic image editing that requires more comprehensive control to satisfy user-desired operations. Therefore, most aforementioned approaches do not meet the requirements. Nonetheless, we categorize the approaches most relevant to our task into two groups: (i) image editing via manipulation in image space, and (ii) image editing via latent space navigation. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/396e29840d9828a2d1068da81859a87debad70ba35b15b3077f0c3d628a6e7d9.jpg",
+        "image_caption": [
+            "Figure 2: Our overall framework (top row) and 3 training strategies different from prior work (bottom row). In (a), $G$ takes $_ { z }$ and an edited latent vector separately to synthesize images. $T = \\{ d _ { 1 } , . . . , d _ { N } \\}$ are the trainable latent-space directions and $\\varepsilon$ represents transformation extent. Original and edited image attributes, $_ { \\pmb { \\alpha } }$ and $\\hat { \\alpha }$ , are predicted by the pre-trained regressor $R$ . The discriminator loss ${ \\mathcal { L } } _ { \\mathrm { d i s c } }$ (the discriminator $D$ not shown due to limited space), the regression loss $\\mathcal { L } _ { \\mathrm { r e g } }$ , and the perceptual loss $\\mathcal { L } _ { \\mathrm { { c o n t e n t } } }$ are used to update $\\mathbf { T }$ . We explain (b-d) in Sec. 3.2. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            88,
+            810,
+            338
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            460,
+            825,
+            502
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Image-space editing using GANs directly manipulates an image for targeted editing. Early work (Isola et al., 2017) used GANs to implement semantic translations between two image domains with paired data, e.g., day to night. Follow-up work focused on multi-modal (Bhattarai & Kim, 2020; Choi et al., 2018; 2020; Lee et al., 2020; Wang et al., 2018; Wu et al., 2019) and unpaired image domain translation (Zhu et al., 2017a). In this case, they primarily consider binary (on/off) attribute changes, regardless of whether the process is dynamic, for example, day to night. ",
+        "bbox": [
+            174,
+            510,
+            823,
+            593
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Latent-space editing via GANs has received an increasing amount of recent interest. Most prior work focused on identifying semantically meaningful directions in the latent space of GANs, so that shifting latent vectors towards these directions achieves the desired image manipulation. Recent papers found semantics in the latent space of GANs, such as color transformations and camera movements (Jahanian et al., 2019), or face attribute changes (Shen et al., 2019), such as smile. Other work considered unsupervised methods (Hark ¨ onen et al., 2020; Voynov & Babenko, 2020) to dis-¨ cover interpretable latent space directions. However, additional challenges inherent to unsupervised manipulation of the latent space arise, and have not been addressed in prior work, e.g., direction quality with regard to degree control and image identity preservation. ",
+        "bbox": [
+            173,
+            599,
+            825,
+            726
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            750,
+            281,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 PROBLEM STATEMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            784,
+            370,
+            797
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider controllable semantic image editing via latent space navigation in GANs. We begin with a fixed GAN model that consists of a generator $G$ and a discriminator $D$ . The input of $G$ is a latent vector $z \\in \\mathbb { R } ^ { m }$ from a latent space $\\mathcal { Z }$ . Here, $m$ is the dimensionality of the latent space. Given $N$ attributes, we aim to discover semantically meaningful latent-space GAN directions, $\\bar { \\pmb { T } } = \\{ { \\pmb d } _ { 1 } , \\ldots , { \\pmb d } _ { N } \\}$ , to manipulate the attributes of synthetic images $G ( z )$ with an assigned step size $\\boldsymbol \\varepsilon = \\{ \\varepsilon _ { 1 } , \\ldots , \\varepsilon _ { N } \\}$ , where $\\pmb { d } _ { i } \\in \\mathbb { R } ^ { m }$ for all $i \\in \\{ 1 , \\ldots , N \\}$ . In the end, each attribute of an edited image can be changed with the corresponding degree $\\varepsilon$ from ${ \\pmb { \\alpha } } = \\{ \\alpha _ { 1 } , . . . , \\alpha _ { N } \\}$ , the original attributes of $G ( z )$ predicted by a regressor $R$ . ",
+        "bbox": [
+            174,
+            813,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 PROPOSED APPROACH",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            369,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We provide an overview of our method in Fig. 2 (a), and further illustrate how our approach differs from prior work in Fig. 2 (b-d). ",
+        "bbox": [
+            173,
+            128,
+            823,
+            159
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Overview. As shown in Fig. 2 (a), we employ a GAN model consisting of a generator $G$ and a discriminator $D$ (not shown due to limited space), as well as a regressor $R$ , all of which are pretrained. Our goal is to find latent directions $\\mathbf { T }$ that provide attribute specific image edits. At each training step, $G$ takes $_ { z }$ and an edited latent vector referred to as $z ^ { \\prime }$ . We follow prior work which suggests that direction vectors in latent space of GANs permit image editing (Jahanian et al., 2019). Formally, given a transformation degree $\\varepsilon$ , we obtain the latent-space edit as $z ^ { \\prime } = z + { \\cal T } \\varepsilon =$ $\\begin{array} { r } { z + \\sum _ { i = 1 } ^ { N } \\varepsilon _ { i } d _ { i } } \\end{array}$ . $G$ provides the recovered and edited images $G ( z )$ and $G ( z ^ { \\prime } )$ , which are separately processed by the regressor to predict attribute values. The original attributes of $R ( G ( z ) )$ . The (pseudo-) ground truth and predicted attribute of $G ( z ^ { \\prime } )$ are $\\alpha ^ { \\prime }$ and $\\hat { \\mathbf { \\alpha } } ^ { \\prime }$ , respectively, where ${ \\pmb { \\alpha } } ^ { \\prime } = { \\pmb { \\alpha } } + { \\pmb { \\varepsilon } }$ and $\\hat { \\pmb { \\alpha } } ^ { \\prime } = R ( G ( \\pmb { z } ^ { \\prime } ) )$ . ",
+        "bbox": [
+            173,
+            164,
+            825,
+            308
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Intuitively, the goal of $_ { \\mathbf { T } }$ is to transform $_ { z }$ by adding semantically meaningful information such that the corresponding output image $G ( z ^ { \\prime } )$ exhibits attribute changes $\\varepsilon$ from $_ { \\pmb { \\alpha } }$ . In practice, we normalize the range of attribute values to $[ \\mathbf { 0 } , \\mathbf { 1 } ]$ , i.e., both $_ { \\pmb { \\alpha } }$ and ${ \\pmb { \\alpha } } ^ { \\prime } \\in [ { \\bf 0 } , { \\bf 1 } ]$ . During training, we maintain the unit range by controlling the given $\\varepsilon$ . Formally, $\\varepsilon$ is drawn from a distribution $\\mathcal { D } _ { \\varepsilon }$ uniform in $[ - 1 , 1 ] ^ { N }$ while considering the constraint that $\\mathbf { 0 } \\leq \\alpha + \\varepsilon \\leq 1$ . ",
+        "bbox": [
+            174,
+            313,
+            825,
+            383
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Objective function. To find $\\mathbf { T }$ we minimize the weighted objective: ",
+        "bbox": [
+            173,
+            390,
+            622,
+            405
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1cf13ccc6410fc13df4ba994f8afdb46b959e91e9dbf0aae868c1aea712c5536.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\pmb { T } } \\pmb { \\mathcal { L } } \\triangleq \\lambda _ { 1 } \\mathcal { L } _ { \\mathrm { r e g } } + \\lambda _ { 2 } \\mathcal { L } _ { \\mathrm { d i s c } } + \\lambda _ { 3 } \\mathcal { L } _ { \\mathrm { c o n t e n t } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            364,
+            411,
+            632,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note, the objective is only used for optimizing $_ { \\mathbf { T } }$ , while the other modules remain fixed. Hyperparameters $\\lambda _ { 1 } , \\lambda _ { 2 }$ , and $\\lambda _ { 3 }$ adjust the loss terms. ",
+        "bbox": [
+            173,
+            441,
+            823,
+            470
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The regression loss $\\mathcal { L } _ { \\mathrm { r e g } }$ assesses whether $_ { \\mathbf { T } }$ performs the transformations indicated by $\\varepsilon$ . We express the regression loss via a binary cross entropy: ",
+        "bbox": [
+            171,
+            477,
+            823,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84d343b799f92402b7e68b74529e12d2219071174d3e8d3b12acee3ec7fd0dc8.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { L } _ { \\mathrm { r e g } } = \\ } & { { } \\mathbb { E } _ { z \\sim \\mathcal { Z } , \\varepsilon \\sim \\mathcal { D } _ { \\varepsilon } } [ - \\hat { \\alpha } ^ { \\prime } \\log \\alpha ^ { \\prime } - ( { \\bf 1 } - \\hat { \\alpha } ^ { \\prime } ) \\log \\left( { \\bf 1 } - \\alpha ^ { \\prime } \\right) ] _ { \\mathrm { t } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            300,
+            511,
+            697,
+            530
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that $\\alpha ^ { \\prime }$ is from the distribution generated by $_ z$ and $\\varepsilon$ . Please refer to the appendix C.1 for more details on this distribution. ",
+        "bbox": [
+            173,
+            535,
+            826,
+            564
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The second loss term ${ \\mathcal { L } } _ { \\mathrm { d i s c } }$ is computed using the discriminator $D$ and measures the quality of the generated images, i.e., ",
+        "bbox": [
+            174,
+            569,
+            823,
+            599
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bbab1a17f99d986c9825ffac191ef03d0aad040386c5c6c81c9a8a84bd98e31d.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { L } _ { \\mathrm { d i s c } } = } & { { } \\ \\mathbb { E } _ { z ^ { \\prime } \\sim \\mathcal { Z } ^ { \\prime } | z } \\left[ \\log ( 1 - D ( G ( z ^ { \\prime } ) ) ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            604,
+            640,
+            625
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Here we refer to the domain of $z ^ { \\prime }$ via $\\mathcal { Z } ^ { \\prime }$ , which is conditioned on $_ z$ . We write this using $\\mathcal { Z } ^ { \\prime } | z$ . ",
+        "bbox": [
+            174,
+            630,
+            794,
+            645
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Lastly, we use a content loss $\\mathcal { L } _ { \\mathrm { { c o n t e n t } } }$ , often also referred to as perceptual loss. It is designed to estimate the distance between two images and it is employed to maintain the image identity during the transformation. Specifically, we use the content loss term ",
+        "bbox": [
+            173,
+            651,
+            820,
+            694
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a63bbf6b2f70798498c313e782c4c925d46483117a840c2b5a5ce26a841dfa2e.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { L } _ { \\mathrm { c o n t e n t } } = } & { \\ \\mathbb { E } _ { z \\sim \\mathcal { Z } , z ^ { \\prime } \\sim \\mathcal { Z } ^ { \\prime } | z } \\displaystyle \\sum _ { i \\in \\mathcal { D } _ { \\mathrm { c o n t e n t } } } \\| F _ { i } ( G ( z ^ { \\prime } ) ) - F _ { i } ( G ( z ) ) \\| _ { 2 } ^ { 2 } , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            290,
+            700,
+            705,
+            734
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { i } ( \\cdot )$ denotes a feature function which extracts intermediate features from images. $\\mathcal { D } _ { \\mathrm { c o n t e n t } }$ indicates the layers of a pre-trained model which are used as features. We approximate the aforementioned expectations by empirical sampling. We defer algorithm details to Appendix A. ",
+        "bbox": [
+            174,
+            741,
+            823,
+            785
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Joint-distribution sampling and training. The regressor operates in a multi-label setting, i.e., each data possesses multiple attributes. To ensure the disentanglement of attribute edits we sample synthetic images from the entire data distribution and find all transformations at once (illustrated in Fig. 2 (b,c) right). In contrast, Shen et al. (2019) prepare training samples on the two opposing data subsets with regards to an attribute, e.g., no clouds vs. many clouds, and find the directions with $N$ one-vs-one classifiers (sketched in Fig. 2 (b,c) left). ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Transformation module $_ { \\mathbf { T } }$ . We study two types of transformations $\\mathbf { T }$ : (i) global and (ii) local. A global transformation $\\mathbf { T }$ refers to a semantic latent-space transformation identical for all $_ z$ during inference. This is illustrated via parallel red dashed arrows in Fig. 2 (d) left. These global directions are commonly used (Hark ¨ onen et al., 2020; Jahanian et al., 2019; Shen et al., 2019; Viazovetskyi ¨ et al., 2020). However, a globally identical direction might not serve all data. In contrast, a local transformation $_ { \\mathbf { T } }$ is a function of $_ z$ which provides various directions for different $_ z$ (in Fig. 2 (d) right, shown via non-parallel red arrows). Formally, $d _ { i } = f _ { \\theta } ^ { i } ( z )$ , where $f _ { \\theta } ^ { i }$ is implemented via a deep net. In Sec. 4 we show that the local transformation $\\mathbf { T }$ succeeds on failure cases of the global transformation. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6d3e6bc1c1ba9ae9062257137ebc1913590a9a30bfac3de55c26f3b4059cfda.jpg",
+        "image_caption": [
+            "Figure 3: Comparison of image-space editing approaches with respect to “removing clouds” (top), “enhancing night” (middle) and “adding snow” (bottom). The original images (col.1) are followed by a given editing task. From (a-e): (a) CycleGAN (Zhu et al., 2017a), (b) StarGAN v2 (Choi et al., 2020), (c) RelGAN (Wu et al., 2019), (d) $\\mathrm { D R I T + + }$ (Lee et al., 2020), and (e) Ours. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            108,
+            815,
+            347
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/8276997cfc6eb8e8ffa6c1fdebf8f9f1218dac268c9fbfd842f4affa8afe9c4e.jpg",
+        "image_caption": [
+            "Figure 4: Comparison of latent-space editing approaches on StyleGAN2. (a) Shen et al. (2019); (b) Voynov & Babenko (2020); (c) Ours. Original synthetic image (col.1); edited results of a semantic manipulation noted on top (col.2-4; col.5-7). Shen & Zhou (2021) mention that “age,” “gender,” and “glasses” directions are hard to disentangle potentially due to data bias, while our results suggest a better direction disentanglement. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            436,
+            815,
+            613
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            726,
+            825,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            326,
+            849
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We introduce datasets, implementation details, evaluation metrics, and show results next. ",
+        "bbox": [
+            171,
+            859,
+            754,
+            875
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Datasets. We evaluate the proposed approach on two types of datasets: (i) face datasets – FFHQ (Karras et al., 2019a), CelebA (Liu et al., 2018) and CelebA-HQ (Karras et al., 2017), commonly used in prior work (Hark ¨ onen et al., 2020; Karras et al., 2017; 2019a;b; Shen et al., 2019; ¨ ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Viazovetskyi et al., 2020). (ii) natural scene datasets – Transient Attribute Database (Laffont et al., 2014) and MIT Places2 data (Zhou et al., 2017), which contain attributes suitable for continuous semantic image editing. We briefly introduce the scene datasets: ",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "• Transient Attribute Database (Laffont et al., 2014): It contains 8,571 scene images with 40 attributes in 5 categories including lighting (e.g., “bright”), weather (e.g., “cloudy”) , seasons (e.g., “winter”), subjective impressions (e.g., “beautiful”), and additional attributes (e.g., “dirty”). Each attribute is annotated with a real-valued score between 0 and 1, where 0 indicates absence of the attribute.   \n• MIT Places2 data (Zhou et al., 2017): Using the provided category annotations (i.e., indoor/outdoor and natural/artificial), we select the natural outdoor scenes, obtaining a total of 144,543 images. ",
+        "bbox": [
+            178,
+            156,
+            825,
+            271
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Implementation details. We choose $\\lambda _ { 1 } = 1 0 , \\lambda _ { 2 } = 0 . 0 5 , \\lambda _ { 3 } = 0 . 0 5$ in Eq. (1) and compute the perceptual loss using the conv1 2, conv2 2, conv3 2, conv4 2 activations in a VGG-19 network (Simonyan & Zisserman, 2014) pre-trained on the ImageNet dataset (Russakovsky et al., 2015). We train $\\mathbf { T }$ for $5 0 \\mathrm { k }$ iterations with a batch size of 4. An Adam optimizer is used with a learning rate of 1e-4. For the latent space $\\mathcal { Z }$ in the proposed method we use the $\\mathcal { W }$ space of StyleGAN2 and the $\\mathcal { Z }$ space of PGGAN. For the attribute regressor $R$ , we adopt a ResNet-50 (He et al., 2016) for attribute prediction on the Transient Attribute (Laffont et al., 2014) and the CelebA (Liu et al., 2018) data. The last fully connected layer in the ResNet-50 is replaced by a linear layer with an output dimension of 40. We train the regressors for 500 epochs and use the weights with the best validation mean squared error (MSE) on CelebA and the best test MSE on the Transient Scene Database. The GAN follows the StyleGAN2 architecture and is pretrained with $2 0 0 \\mathrm { k }$ iterations on a union of the two natural scene datasets using a resolution of $2 5 6 \\times 2 5 6$ . The training batch size is 32 and an Adam optimizer is used with a learning rate of 2e-3. For the face datasets, we use FFHQ pre-trained weights1 of StyleGAN2, and CelebA-HQ weights of $\\mathrm { P G G A N } ^ { 2 }$ . ",
+        "bbox": [
+            173,
+            282,
+            825,
+            477
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Baselines. We compare our approach to several popular image-to-image translation approaches (Choi et al., 2020; Wu et al., 2019; Zhu et al., 2017a) and latent space direction discovery methods (Shen et al., 2019; Voynov & Babenko, 2020). Since Choi et al. (2020); Shen et al. (2019); Zhu et al. (2017a) cannot deal with continuous attributes, we split the data into 2 domains using a threshold value of 0.5 for each of the 40 attributes. Afterward, the models are trained on 2 contrast domains, e.g., with or without a certain attribute. We use the official code of all baseline methods and rigorously follow their training steps. Note that work by Voynov & Babenko (2020) is unsupervised, i.e., the latent-space directions are human interpreted. To avoid bias during the selection of directions, we use the attribute regressor to automatically identify the most significant directions that can edit predetermined attributes. The details of preparing the baselines are given in Appendix C.2. ",
+        "bbox": [
+            173,
+            484,
+            825,
+            622
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Evaluation metrics. There is no good numerical metric to evaluate image editing (Shen et al., 2019; Voynov & Babenko, 2020). In an attempt to address this concern, we automate quantitative evaluation based on a property that editing of attributes should maintain image identity. To achieve this, we employ a popular image identity recognition model3 pre-trained on the VGGface2 data (Cao et al., 2018). Cosine similarity is used to represent the similarity between paired original and edited images (Cao et al., 2018). In addition, we evaluate changes of the other independent attributes using the pre-trained regressor. ",
+        "bbox": [
+            173,
+            630,
+            825,
+            727
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 RESULTS ON NATURAL SCENE DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            748,
+            495,
+            762
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparison to image-to-image translation: As shown in Fig. 3 (a-d), we observe image-to-image translation to perform poorly when editing image details (e.g., removing clouds). Moreover, sometimes artifacts (orange spots in (a) and (b)) are introduced. In contrast, our model shows overall compelling transfer performance on all these attributes. ",
+        "bbox": [
+            174,
+            775,
+            825,
+            830
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Comparison to latent-space translation: Inspecting Fig. 1, we observe our approach to improve upon work by Shen et al. (2019) in attribute edit quality and number of artifacts. Similarly, in ",
+        "bbox": [
+            176,
+            838,
+            823,
+            866
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/2a075a8f6392e39967cfd1bca5063ddb38b1894f9895b367a74c0bc9a135410e.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            112,
+            383,
+            185
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Question1: Compared to the picture on the left, how cloudy is the picture on the right? ",
+        "bbox": [
+            186,
+            191,
+            398,
+            215
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/73703449f7e679fa02f343ed6f43883fb95d0b5197a5344311e448950de5bd4b.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            415,
+            106,
+            815,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Question2: Ignoring the attribute clouds, determine if the two pictures record the same scene. ",
+        "bbox": [
+            186,
+            222,
+            388,
+            256
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/779850f4a63da68102681994d49d10d728dc794f9dc3158d85d16ae82a39bfd4.jpg",
+        "image_caption": [
+            "Figure 5: User study for image editing and image identity preservation. Blue bars show the predicted presence of a given attribute for images $( I +$ , higher is better). The orange bars measure the difference between paired images (lower is better). ",
+            "Figure 6: Real image synthesis with multiple attributes. Shen et al. (2019) (top row); ours (bottom row): original real image (col.1); inverted result (col.2) from Abdal et al. (2019); edited results (col.3-7) with target attribute changes shown at the bottom. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            338,
+            820,
+            506
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Fig. 4, we notice that our method performs well in attribute editing, and has a better ability to preserve image identity when adding “night” and “snow.” We show additional analysis and results in Appendix D and E.1. ",
+        "bbox": [
+            173,
+            574,
+            825,
+            616
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation: We follow a user study proposed by Kowalski et al. (2020) to evaluate controllability of our scene edits. Concretely, given an image $I = G ( z )$ , we generate paired images $( I + , I - )$ that have opposing values for attribute $n$ . 40 users took the test to answer: (a) the presence and strength of the attribute $n$ in $^ { I + }$ , and (b) if $I +$ and $I -$ are identical when ignoring the attribute. Both types of questions have options on a 5-level scale from 0 (“not at all”) to 1 (“totally”). Ideally, the response to question (a) should be 1 while we expect replies for (b) to be 0. We test performance of image editing with “clouds”, “sunrise&sunset”, “night” and “snow” attributes. A question example and statistical results over 50 image pairs are shown in Fig. 5. Statistical evidence supports our claim that the proposed approach performs well with regards to image edits while maintaining image identity. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            762
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ON FACE DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            779,
+            415,
+            792
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Manipulation results on StyleGAN2: The comparison on real images shown in Fig. 1 suggests that our method works well for attribute edits. Further, the synthetic image edit results in Fig. 4 indicate that our edits are disentangled, while the baselines unexpectedly add “glasses” when aging the face. To increase the task difficulty, we edit real images with multiple attribute changes simultaneously. Results are summarized in Fig. 6, which highlights the controllability of our edits. ",
+        "bbox": [
+            174,
+            804,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Quantitative evaluation: We measure the changing degrees of the other independent attributes and the image identity when editing attributes with various degrees $\\hat { \\varepsilon }$ . Here $\\hat { \\varepsilon }$ is a predicted changing degree on a target attribute by $R$ . For a thorough comparison, we evaluate the performance on 3 segments according to the absolute value of $\\hat { \\varepsilon }$ , i.e., $| \\hat { \\varepsilon } |$ in the range of $( 0 , 0 . 3 ]$ , (0.3, 0.6] and (0.6, 0.9]. Evaluation on “smile,” “hair color,” and “smile+hair color” attributes are shown in Tab. 1 and Tab. 2. The “hair color” attribute includes “blond” and “black” colors where we average the results on both cases. For multiple attribute editing, “smile $^ +$ hair color,” we evaluate the case that both the two targeted attributes change within the $| \\hat { \\varepsilon } |$ range. We use around 1k original images, generate $1 0 \\mathrm { k }$ edited images with regard to each target attribute, and repeat the experiment 3 times. The averaged results and the standard deviations presented in Tab. 1 and Tab. 2 suggest that our model outperforms the baselines with regard to disentanglement and image identity preservation. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6befb6d6ec2e53040e29b5d9fd95e4787eb57a5a0b06a99590158e80057fe3af.jpg",
+        "table_caption": [
+            "Table 1: Quantitative evaluation of numerical changes on the other semantically independent attributes (lower is better). (first row) edited attributes; (second row) the absolute changing range of the edited attributes; (bottom three rows) averages (up) and standard deviations (down) in each row. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td colspan=\"3\">Smile</td><td colspan=\"3\">Hair color</td><td colspan=\"3\">Smile + Hair color</td></tr><tr><td></td><td>(0,.3]</td><td>(.3,.6]</td><td>(.6,.9]</td><td>(0,.3]</td><td>(.3, 6] (.6,.9]</td><td></td><td>(0,.3]</td><td>(.3,.6]</td><td>(.6,.9]</td></tr><tr><td>Shen et al.</td><td>.202 ±5e-2</td><td>.204 ±6e-2</td><td>.224 ±4e-2</td><td>.256 ±1e-2</td><td>.272 ±2e-2</td><td>.277 ±2e-2</td><td>.299 ±5e-3</td><td>.318 ±1e-2</td><td>.329 ±3e-2</td></tr><tr><td>Voynov et al.</td><td>.115 ± 6e-3</td><td>.211 ±4e-2</td><td>.277</td><td>.162</td><td>.166</td><td>.177</td><td>.155</td><td>.220 ±4e-2</td><td>.284 ±2e-2</td></tr><tr><td>Ours</td><td>.085 ±4e-2</td><td>.084 ±3e-3</td><td>±7e-3 .098 ±4e-3</td><td>±1e-2 .075 ±7e-4</td><td>±3e-2 .083 ±5e-3</td><td>±9e-3 .084 ±5e-3</td><td>±4e-3 .088 ±7e-3</td><td>.111 ±4e-3</td><td>.134 ±4e-3</td></tr></table>",
+        "bbox": [
+            202,
+            99,
+            795,
+            242
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/f56e615daf9cbffd26483bde8850fc7d63006749c13e85f773ea4e03fdb4da8f.jpg",
+        "table_caption": [
+            "Table 2: Quantitative evaluation on image identity preservation (higher is better). Notation is identical to Tab. 1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>Smile</td><td></td><td></td><td>Hair color</td><td></td><td></td><td>Smile+Haircolor</td><td></td></tr><tr><td></td><td>(0,.3] (.3,.6] (.6,.9] (0,.3] (.3,.6] (.6,.9] (0,.3] (.3,.6] (.6,.9)</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Shen et al.</td><td>.918.916.907.887.877.874.877.819.801 ± 4e-3 ±1e-3 ± 5e-3 ±3e-2 ± 4e-2 ±4e-2 ± 6e-3 ± 3e-2 ±4e-2</td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>Voynov et al.</td><td>.979</td><td></td><td></td><td></td><td></td><td></td><td></td><td>.896.869.955.909.904.940.829.811</td></tr><tr><td>Ours</td><td>.995.994.992.993.993.993.992.986.984</td><td></td><td></td><td></td><td></td><td></td><td></td><td>± 2e-3 ±4e-3 ± 9e-3 ± 6e-2 ±4e-2 ±3e-2 ±9e-3 ± 4e-2 ±3e-2 ± 7e-4 ± 1e-3 ± 9e-4 ± 5e-4 ±1e-4 ± 2e-4 ± 9e-4 ± 2e-3 ± 4e-4</td></tr></table>",
+        "bbox": [
+            210,
+            325,
+            787,
+            467
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            539,
+            825,
+            651
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Manipulation results on PGGAN: For PGGAN, we use local transformations parameterized by three-layer perceptrons with leaky ReLU activations. We show the detailed MLP architecture in Appendix B.1. Editing results in Fig. 7 suggest that the proposed approach is able to continuously edit faces with various semantic attributes. We also study the differences between local and global directions in Fig. 11. Particularly, a global $\\mathbf { T }$ (in Fig. 11 (a)) is a matrix where each column $i$ is given by $\\mathbf { \\ b { d } } _ { i }$ . For a local $\\mathbf { T }$ (in Fig. 11 (b)) $\\mathbf { \\ b { d } } _ { i }$ is given by a fully-connected layer with identical input and output dimensions. Fig. 11 (c) and (d) use the MLP components with the aforementioned structure. We use $\\mathcal { L } _ { \\mathrm { r e g } }$ to train $\\mathbf { T }$ in (c), while the total loss $\\mathcal { L }$ is used for (d). The results in Fig. 11 indicate that a local $_ { \\mathbf { T } }$ , with either linear or MLP structure works well for face attribute edits. Moreover, our loss $\\mathcal { L }$ stabilizes the training process of $\\mathbf { T }$ . ",
+        "bbox": [
+            173,
+            657,
+            825,
+            797
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/4fa6e5104333e00a1e806c7aae8b7cd5a1fcdbf707a582fbe68a63e86a89de99.jpg",
+        "image_caption": [
+            "Figure 7: Continuous editing results on PGGAN (Karras et al., 2017) with the “black hair” (left) and the “smile” (right) attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            827,
+            836,
+            896
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/65a0ce13abac868def241a0d1ed0540afe7ab5e45559a10ee00dfd0c82016709.jpg",
+        "image_caption": [
+            "Figure 8: Comparison of global and local transformations on PGGAN. Original synthetic images (col.1); the edited results on enhancing “smile” (col.2-5): (a) a global $_ { \\mathbf { T } }$ , (b) a local $\\mathbf { T }$ , with linearlayer direction functions, (c) a local $\\mathbf { T }$ with MLP direction functions trained via $\\mathcal { L } _ { \\mathrm { r e g } }$ loss only, and (d) a local $_ { \\mathbf { T } }$ with MLP direction functions training via the entire loss $\\mathcal { L }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            94,
+            751,
+            268
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            356,
+            318,
+            371
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We propose an effective approach to semantically edit images by transferring latent vectors towards meaningful latent space directions. The proposed method enables continuous image manipulations with respect to various attributes. Extensive experiments highlight that the model achieves state-ofthe-art performance for targeted image manipulation. ",
+        "bbox": [
+            173,
+            377,
+            825,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements: This work is supported in part by NSF under Grant No. 1718221, 2008387, 1934986 and MRI #1725729, NIFA award 2020-67021-32799, UIUC, Samsung, Amazon, 3M, and Cisco Systems Inc. (Gift Award CG 1377144). We thank Cisco for access to the Arcetri cluster. We thank Amazon for EC2 credits. ",
+        "bbox": [
+            173,
+            440,
+            825,
+            496
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            517,
+            285,
+            534
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Rameen Abdal, Yipeng Qin, and Peter Wonka. Image2stylegan: How to embed images into the stylegan latent space? In ICCV, 2019.   \nBinod Bhattarai and Tae-Kyun Kim. Inducing optimal attribute representations for conditional gans. ECCV, 2020.   \nAndrew Brock, Jeff Donahue, and Karen Simonyan. Large scale gan training for high fidelity natural image synthesis. arXiv, 2018.   \nQ. Cao, L. Shen, W. Xie, et al. Vggface2: A dataset for recognising faces across pose and age. In IEEE FG, 2018.   \nYunjey Choi, Minje Choi, Munyoung Kim, et al. Stargan: Unified generative adversarial networks for multi-domain image-to-image translation. In CVPR, 2018.   \nYunjey Choi, Youngjung Uh, Jaejun Yoo, et al. Stargan v2: Diverse image synthesis for multiple domains. CVPR, 2020.   \nIan Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, et al. Generative adversarial nets. In NeurIPS, 2014.   \nErik Hark ¨ onen, Aaron Hertzmann, Jaakko Lehtinen, et al. Ganspace: Discovering interpretable gan ¨ controls. arXiv, 2020.   \nKaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In CVPR, 2016.   \nPhillip Isola, Jun-Yan Zhu, Tinghui Zhou, et al. Image-to-image translation with conditional adversarial networks. In CVPR, 2017. ",
+        "bbox": [
+            171,
+            541,
+            826,
+            925
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ali Jahanian, Lucy Chai, and Phillip Isola. On the”steerability” of generative adversarial networks. ICLR, 2019. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            133
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alexia Jolicoeur-Martineau. The relativistic discriminator: a key element missing from standard gan. ICLR, 2019. ",
+        "bbox": [
+            173,
+            141,
+            823,
+            171
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Timo Aila, Samuli Laine, et al. Progressive growing of gans for improved quality, stability, and variation. arXiv, 2017. ",
+        "bbox": [
+            174,
+            179,
+            823,
+            209
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, and Timo Aila. A style-based generator architecture for generative adversarial networks. In CVPR, 2019a. ",
+        "bbox": [
+            173,
+            218,
+            823,
+            248
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tero Karras, Samuli Laine, Miika Aittala, et al. Analyzing and improving the image quality of stylegan. arXiv, 2019b. ",
+        "bbox": [
+            173,
+            257,
+            823,
+            286
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Marek Kowalski, Stephan J Garbin, Virginia Estellers, Tadas Baltrusaitis, Matthew Johnson, and ˇ Jamie Shotton. Config: Controllable neural face image generation. ICML, 2020. ",
+        "bbox": [
+            171,
+            295,
+            823,
+            325
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre-Yves Laffont, Zhile Ren, Xiaofeng Tao, et al. Transient attributes for high-level understanding and editing of outdoor scenes. TOG, 2014. ",
+        "bbox": [
+            173,
+            333,
+            823,
+            364
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "H.Y. Lee, H.Y. Tseng, Q. Mao, et al. Drit++: Diverse image-to-image translation via disentangled representations. IJCV, 2020. ",
+        "bbox": [
+            173,
+            372,
+            823,
+            401
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bowen Li, Xiaojuan Qi, Thomas Lukasiewicz, and Others. Controllable text-to-image generation. In NeurIPS, 2019. ",
+        "bbox": [
+            174,
+            411,
+            821,
+            440
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y. Li, C. Fang, J. Yang, et al. Universal style transfer via feature transforms. In NeurIPS, 2017. ",
+        "bbox": [
+            171,
+            449,
+            797,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ziwei Liu, Ping Luo, Xiaogang Wang, et al. Large-scale celebfaces attributes (celeba) dataset. 2018. ",
+        "bbox": [
+            171,
+            474,
+            820,
+            491
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "F. Luan, S. Paris, and E. andothers Shechtman. Deep photo style transfer. In PCVPR, 2017. ",
+        "bbox": [
+            173,
+            498,
+            776,
+            515
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Taesung Park, Ming-Yu Liu, Ting-Chun Wang, and Jun-Yan Zhu. Semantic image synthesis with spatially-adaptive normalization. In CVPR, 2019. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            554
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Antoine Plumerault, Herve Le Borgne, and C ´ eline Hudelot. Controlling generative models with ´ continuous factors of variations. ICLR, 2020. ",
+        "bbox": [
+            174,
+            561,
+            823,
+            592
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Olga Russakovsky, Jia Deng, Hao Su, et al. Imagenet large scale visual recognition challenge. ICCV, 2015. ",
+        "bbox": [
+            176,
+            601,
+            821,
+            630
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujun Shen and Bolei Zhou. Closed-form factorization of latent semantics in gans. CVPR, 2021. ",
+        "bbox": [
+            176,
+            638,
+            808,
+            655
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yujun Shen, Jinjin Gu, Xiaoou Tang, et al. Interpreting the latent space of gans for semantic face editing. 2019. ",
+        "bbox": [
+            173,
+            664,
+            825,
+            694
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv, 2014. ",
+        "bbox": [
+            171,
+            702,
+            825,
+            732
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yuri Viazovetskyi, Vladimir Ivashkin, and Evgeny Kashin. Stylegan2 distillation for feed-forward image manipulation. arXiv, 2020. ",
+        "bbox": [
+            171,
+            741,
+            825,
+            771
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Andrey Voynov and Artem Babenko. Unsupervised discovery of interpretable directions in the gan latent space. ICML, 2020. ",
+        "bbox": [
+            173,
+            779,
+            823,
+            809
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sheng-Yu Wang, Oliver Wang, Richard Zhang, et al. Cnn-generated images are surprisingly easy to spot... for now. CVPR, 2019a. ",
+        "bbox": [
+            171,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sheng-Yu Wang, Oliver Wang, et al. Detecting photoshopped faces by scripting photoshop. In ICCV, 2019b. ",
+        "bbox": [
+            174,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ting-Chun Wang, Ming-Yu Liu, Jun-Yan Zhu, et al. High-resolution image synthesis and semantic manipulation with conditional gans. In CVPR, 2018. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Po-Wei Wu, Yu-Jing Lin, Che-Han Chang, et al. Relgan: Multi-domain image-to-image translation via relative attributes. In ICCV, 2019. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Han Zhang, Ian Goodfellow, Dimitris Metaxas, et al. Self-attention generative adversarial networks. PMLR, 2018. ",
+        "bbox": [
+            171,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Bolei Zhou, Agata Lapedriza, Aditya Khosla, et al. Places: A 10 million image database for scene recognition. TPAMI, 2017. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Taesung Park, Phillip Isola, et al. Unpaired image-to-image translation using cycleconsistent adversarial networks. In ICCV, 2017a. ",
+        "bbox": [
+            169,
+            217,
+            823,
+            246
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jun-Yan Zhu, Richard Zhang, Deepak Pathak, et al. Toward multimodal image-to-image translation. In NeurIPS, 2017b. ",
+        "bbox": [
+            169,
+            253,
+            823,
+            284
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            281,
+            118
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. ALGORITHM ",
+        "bbox": [
+            176,
+            132,
+            326,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "The overall procedure of the proposed method in Algorithm 1, taking local transformation $\\mathbf { T }$ as an example. ",
+        "bbox": [
+            176,
+            159,
+            825,
+            186
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 Training Procedure ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            200,
+            392,
+            215
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Input: A pre-trained GAN with $G$ , $D$ , and input noise distribution $z \\sim \\mathcal { Z }$ ; a pre-trained regressor   \n$R$ for predictions on $_ \\mathrm { N }$ attributes; an initialized $\\mathbf { T }$ ; max iteration number $M$ .   \n1: for iteration $m = 1 , \\ldots , M$ do   \n2: Sample random noise $z \\sim \\mathcal { Z }$ , and $\\varepsilon$   \n3: Compute internal attributes for a synthetic image, i.e., ${ \\pmb \\alpha } = R ( G ( { \\pmb z } ) )$   \n4: Compute the actual shift value $\\pmb { \\delta } = C L I P ( \\pmb { \\alpha } + \\pmb { \\varepsilon } , ( 0 , 1 ) ) - \\pmb { \\alpha }$   \n5: Compute the transformed latent vector $z ^ { \\prime } = z + { \\cal T } ( z ) \\delta$   \n6: Compute $I ^ { \\prime } = G ( z ^ { \\prime } )$ , ${ \\pmb { \\alpha } } ^ { \\prime } = { \\pmb { \\alpha } } + { \\pmb { \\delta } }$   \n7: Compute attribute predictions $\\hat { \\pmb { \\alpha } } ^ { \\prime } = { \\cal R } ( { \\cal I ^ { \\prime } } )$   \n8: Compute the loss $\\mathcal { L }$   \n9: Update $\\mathbf { T }$ ",
+        "bbox": [
+            176,
+            218,
+            825,
+            371
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "10: end for Return: T ",
+        "bbox": [
+            174,
+            371,
+            253,
+            398
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B. METHOD DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            370,
+            445
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B.1. METHOD ON PGGAN ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            403,
+            470
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We apply a multi-layer perceptron (MLP) to parameterize a latent space path on PGGAN. Fig. 9 shows the MLP architecture that we use. ",
+        "bbox": [
+            173,
+            479,
+            823,
+            508
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/b73e22acdc9562bd91a2933f94ca6e6ff199eae5f9734ff99eb3251d59132010.jpg",
+        "image_caption": [
+            "Figure 9: Example MLP architecture on PGGAN. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            411,
+            551,
+            571,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In practice, we find that normalizing the direction vector $\\mathbf { \\ b { d } } _ { i }$ helps preserve image identity during manipulation on PGGAN. Formally, the transformed latent vector can be written as ",
+        "bbox": [
+            173,
+            843,
+            823,
+            872
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8846eaed78b1a1bc3282a3120eb7d291f1baebaea53810bfb7dc5a4e9a836f1f.jpg",
+        "text": "$$\nz ^ { \\prime } = z + \\lambda \\varepsilon { \\frac { d _ { i } } { \\parallel d _ { i } \\parallel } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            875,
+            562,
+            907
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a weight adjusting the direction scale. We set $\\lambda = 3$ . ",
+        "bbox": [
+            173,
+            909,
+            591,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "C. EXPERIMENTAL DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            433,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.1 THE EXPECTATION IN $\\mathcal { L } _ { \\mathrm { { R E G } } }$ ",
+        "bbox": [
+            174,
+            128,
+            392,
+            145
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We define the regression loss $\\mathcal { L } _ { \\mathrm { r e g } }$ as ",
+        "bbox": [
+            176,
+            155,
+            415,
+            170
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7d290e5bf22b3369bd3b12d080a587bb5027cd3440c4c919326b9ad0a137e90a.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\mathcal { L } _ { \\mathrm { r e g } } = \\ } & { { } \\mathbb { E } _ { z \\sim \\mathcal { Z } , \\varepsilon \\sim \\mathcal { D } _ { \\varepsilon } } [ - \\hat { \\alpha } ^ { \\prime } \\log \\alpha ^ { \\prime } - ( { \\bf 1 } - \\hat { \\alpha } ^ { \\prime } ) \\log \\left( { \\bf 1 } - \\alpha ^ { \\prime } \\right) ] , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            172,
+            694,
+            190
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where $\\alpha ^ { \\prime }$ is from the distribution generated by $_ z$ and $\\varepsilon$ . We now discuss how we derive the distribution of $\\alpha ^ { \\prime }$ . To begin, $_ { z }$ is sampled from $\\mathcal { Z }$ and $\\varepsilon$ is sampled from $\\mathcal { D } _ { \\varepsilon }$ . The other variables are generated by $_ z$ and $\\varepsilon$ : ",
+        "bbox": [
+            178,
+            190,
+            823,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/54c2f56fa908bf04ffb48007d9cfaa8a6a15f62faca42b8bb9f92c992c27eb50.jpg",
+        "text": "$$\n\\begin{array} { r l } & { z ^ { \\prime } = z + \\pmb { T } \\pmb { \\varepsilon } } \\\\ & { \\pmb { \\alpha } ^ { \\prime } = \\boldsymbol { R } ( G ( z ) ) + \\pmb { \\varepsilon } } \\\\ & { \\hat { \\pmb { \\alpha } } ^ { \\prime } = \\boldsymbol { R } ( G ( z ^ { \\prime } ) ) . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            227,
+            566,
+            285
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As a result, the distribution of $\\alpha ^ { \\prime }$ is dependent on $\\mathcal { Z }$ and $\\mathcal { D } _ { \\varepsilon }$ . ",
+        "bbox": [
+            173,
+            285,
+            570,
+            300
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C.2 UNSUPERVISED LATENT-SPACE EDITS OF GANS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            316,
+            537,
+            330
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Voynov & Babenko (2020) learn a matrix where each column is a direction. Yet, Voynov & Babenko (2020) require a human to interpret the learnt directions. To avoid bias during the selection of directions in our comparison, we use the pre-trained attribute regressor to automatically identify the most significant directions. Concretely, we first generate 100 images and edit them with target attributes of various degrees. Next, we use the regressor $R$ on the edited images to predict attributes. We choose for an attribute edit the direction on which all the edited images have the overall highest changing response on the target attribute. ",
+        "bbox": [
+            173,
+            342,
+            825,
+            440
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D. ADDITIONAL ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            392,
+            469
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D.1 GAN INVERSION PERFORMANCE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            482,
+            434,
+            496
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We use an optimization-based GAN inversion method (Abdal et al., 2019) to find optimal latent vectors that can best reconstruct the real images via the generator. To examine the effect of GAN inversion performance on our approach, we terminated the GAN inversion approach at different training steps, i.e., 500 and 4,000 iterations. We show averaged reconstruction MSE loss in Tab. 3. In this case, we reconstructed 20 real face images and edited their “Smile” and the “Blond hair” attribute with 10 different degrees $\\varepsilon$ , i.e., 200 images in total for each attribute editing. Quantitative evaluation on image identity preservation and numerical changes on the other semantically independent attributes for the reconstructed face images are given in Tab. 4. The results in Tab. 4 suggest that the performance of the GAN inversion method affects our method to some degree. Visualized inversion and editing results are shown in Fig. 10. The qualitative results suggest that our method still works remarkably well on the worse inversion image. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/b353d3242d046ba95c2ab2b07c2fac855867210eb3d383b29086be109ac4732e.jpg",
+        "table_caption": [
+            "Table 3: Averaged MSE loss of reconstructing 20 real face images. The GAN inversion method (Abdal et al., 2019) was trained and terminated at $4 \\mathrm { k \\Omega }$ and 500 iterations with averaged MSE loss in the right column. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Training iterations</td><td>MSE</td></tr><tr><td>4k iters</td><td>1657.40</td></tr><tr><td>500 iters</td><td>3096.75</td></tr></table>",
+        "bbox": [
+            388,
+            724,
+            604,
+            784
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D.2 ABLATION STUDY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            801,
+            331,
+            815
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We conduct an ablation study with single- and joint-distribution training strategies in our method. Specifically, single-distribution sampling refers to learn one attribute direction at a time. In contrast, joint-distribution training means to train multiple attribute directions simultaneously. Fig. 11 shows the visualized results with the two training strategies on the face and the scene dataset. We observe that the model with the single-distribution training strategy generates more unexpected changes as the manipulation degree is getting large, e.g., darker scene colors by the model trained for a single attribute, shown in Fig. 11 (b). ",
+        "bbox": [
+            173,
+            825,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/a994c5ec868514ac66d0a20ab1aacec8f673989a2bc20a53b74b5fe12fcd4cec.jpg",
+        "table_caption": [
+            "Table 4: Quantitative evaluation of identity preservation $\\mathbf { \\Pi } ^ { ( \\mathbf { I I D } ) }$ and attribute changes (Attr). We edited two attributes for the real face images, i.e., “Smile” (col.2-7) and “Blond hair” (col.8-13). "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"7\">Smile</td><td colspan=\"6\">Blond hair</td></tr><tr><td></td><td></td><td>ID (↑)</td><td></td><td></td><td>Attr (↓)</td><td></td><td>ID(↑)</td><td></td><td></td><td>Attr (↓)</td><td></td><td></td></tr><tr><td>国</td><td>(0,.3]</td><td>(.3,.6]</td><td>(.6,.9] (0, .3]</td><td></td><td></td><td>(.3,.6] (.6,.9]</td><td>(0,.3] (.3,.6]</td><td></td><td>(.6,.9] (0,.3] (.3,.6] (.6,.9]</td><td></td><td></td><td></td></tr><tr><td>4k iters 500 iters</td><td>.997 .996</td><td>.994 .99</td><td>.986 .982</td><td>.077 .087</td><td>.108 .138</td><td>.147 .165</td><td>.988 .978</td><td>.979 .936</td><td>.94 .914</td><td>.1 .122</td><td>.112 .158</td><td>.16 .185</td></tr></table>",
+        "bbox": [
+            173,
+            142,
+            830,
+            219
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/af8db2995983534031404349d44950bd87eef7c591b07f228e520b77de7cd045.jpg",
+        "image_caption": [
+            "Figure 10: Visual comparisons of “Smile” editing with different reconstructed images: (col.1) Original image; (col.2) reconstructed images with 500 (top) and $4 \\mathrm { k }$ (bottom) inversion optimization steps; (col.3-6) results of editing the “Smile” attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            243,
+            238,
+            754,
+            411
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E. ADDITIONAL RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            496,
+            406,
+            511
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "E.1 SCENE IMAGE EDITS ON STYLEGAN2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            534,
+            537
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We show more results of our method on continuous scene image edits in Fig. 12 - 15. The semantically edited attributes include “clouds” (Fig. 12), “brightness” (Fig. 13), “snow” (Fig. 14), and “summer” (Fig. 15). ",
+        "bbox": [
+            174,
+            547,
+            825,
+            590
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "F. BROADER IMPACT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            607,
+            343,
+            622
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "From an application perspective, our method is effective and efficient with regard to image manipulation and photo-realism, which we hope will contribute to 2D and 3D controllable image editing tasks. Moreover, usage of deep nets to learn mappings between spaces is still not well understood, e.g., mappings between low-dimensional space and image space in classification and generation tasks. We hope our method provides inspiration for representation learning and a first step for a new view with regard to deep net interpretability. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            717
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Obviously, we are aware of the dangers of automated image manipulation. Similar to deepfake tasks whose aim is to produce fabricated images and videos that appear to be real, improper use of image manipulation approaches might raise negative issues with regard to information security, property, etc. Beyond that, edited image detection techniques Wang et al. (2019a;b) are proposed recently to avoid the aforementioned issues, which promotes growth in both domains. ",
+        "bbox": [
+            174,
+            724,
+            825,
+            794
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/070499f2f63fa653dfec515acb1f5e8b3c6dcbe6b26fef8e4ea673ab6cbf7190.jpg",
+        "image_caption": [
+            "Figure 11: Visual comparisons of single- and joint-distribution training. Single-distribution training refers to train one attribute direction at a time, while joint-distribution training means to train multiple attribute directions simultaneously. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            183,
+            103,
+            818,
+            271
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/191cda68622e417c6d8420dd5a11163fe54fe664b24042948c573d3330369ea7.jpg",
+        "image_caption": [
+            "Figure 12: Additional results. Continuous image edits using StyleGAN2 (Karras et al., 2019b) on the “clouds” attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            338,
+            823,
+            491
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/18b8b7a561e6889f43597a128284efa207895a9e0477c5d4698ddd06161657af.jpg",
+        "image_caption": [
+            "Figure 13: Additional results. Continuous image edits using StyleGAN2 (Karras et al., 2019b) on the “brightness” attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            536,
+            823,
+            689
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/ff2234514908b69cd7c90051e7852b66cdc1b435be6dd2d622ff6f37ebbd9971.jpg",
+        "image_caption": [
+            "Figure 14: Additional results. Continuous image edits using StyleGAN2 (Karras et al., 2019b) on the “snow” attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            734,
+            823,
+            888
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/683ee00e8b0863b6e305268599fb5308be987905f6b832d5f8490b4a0911e2b8.jpg",
+        "image_caption": [
+            "Figure 15: Additional results. Continuous image edits using StyleGAN2 (Karras et al., 2019b) on the “summer” attribute. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            416,
+            823,
+            569
+        ],
+        "page_idx": 15
+    }
+]

parse/train/S18Su--CW/S18Su--CW.md

@@ -0,0 +1,353 @@
+# THERMOMETER ENCODING: ONE HOT WAY TO RESIST ADVERSARIAL EXAMPLES
+
+Jacob Buckman∗ †, Aurko Roy∗, Colin Raffel, Ian Goodfellow   
+Google Brain   
+Mountain View, CA   
+{buckman, aurkor, craffel, goodfellow}@google.com
+
+# ABSTRACT
+
+It is well known that it is possible to construct “adversarial examples” for neural networks: inputs which are misclassified by the network yet indistinguishable from true data. We propose a simple modification to standard neural network architectures, thermometer encoding, which significantly increases the robustness of the network to adversarial examples. We demonstrate this robustness with experiments on the MNIST, CIFAR-10, CIFAR-100, and SVHN datasets, and show that models with thermometer-encoded inputs consistently have higher accuracy on adversarial examples, without decreasing generalization. State-of-the-art accuracy under the strongest known white-box attack was increased from $9 3 . 2 0 \%$ to $9 4 . 3 0 \%$ on MNIST and $5 0 . 0 0 \%$ to $7 9 . 1 6 \%$ on CIFAR-10. We explore the properties of these networks, providing evidence that thermometer encodings help neural networks to find more-non-linear decision boundaries.
+
+# 1 INTRODUCTION AND RELATED WORK
+
+Adversarial examples are inputs to machine learning models that are intentionally designed to cause the model to produce an incorrect output. The term was introduced by Szegedy et al. (2014) in the context of neural networks for computer vision. In the context of spam and malware detection, such inputs have been studied earlier under the name evasion attacks (Biggio et al., 2013). Adversarial examples are interesting from a scientific perspective, because they demonstrate that even machine learning models that have superhuman performance on I.I.D. test sets fail catastrophically on inputs that are modified even slightly by an adversary. Adversarial examples also raise concerns in the emerging field of machine learning security because malicious attackers could use adversarial examples to cause undesired behavior (Papernot et al., 2016).
+
+Unfortunately, there is not yet any known strong defense against adversarial examples. Adversarial examples that fool one model often fool another model, even if the two models are trained on different training examples (corresponding to the same task) or have different architectures (Szegedy et al., 2014), so an attacker can fool a model without access to it. Attackers can improve their success rate by sending inputs to a model, observing its output, and fitting their own own copy of the model to the observed input-output pairs (Papernot et al., 2016). Attackers can also improve their success rate by searching for adversarial examples that fool multiple different models—such adversarial examples are then much more likely to fool the unknown target model (Liu et al., 2016). Szegedy et al. (2014) proposed to defend the model using adversarial training (training on adversarial examples as well as regular examples) but it was not feasible to generate enough adversarial examples in the inner loop of the training process for the method to be effective at the time. Szegedy et al. (2014) used a large number of iterations of L-BFGS to produce their adversarial examples. Goodfellow et al. (2014) developed the fast gradient sign method (FGSM) of generating adversarial examples and demonstrated that adversarial training is effective for reducing the error rate on adversarial examples. A major difficulty of adversarial training is that it tends to overfit to the method of adversarial example generation used at training time. For example, models trained to resist FGSM adversarial examples usually fail to resist L-BFGS adversarial examples. Kurakin et al. (2016) introduced the basic iterative method (BIM) which lies between FGSM and L-BFGS on a curve trading speed for effectiveness (the BIM consists of running FGSM for a medium number of iterations). Adversarial training using BIM still overfits to the BIM, unfortunately, and different iterative methods can still successfully attack the model. Recently, Madry et al. (2017) showed that adversarial training using adversarial examples created by adding random noise before running BIM results in a model that is highly robust against all known attacks on the MNIST dataset. However, it is less effective on more complex datasets, such as CIFAR. A strategy for training networks which are robust to adversarial attacks across all contexts is still unknown. In this work, we demonstrate that thermometer code discretization and one-hot code discretization of real-valued inputs to a model significantly improves its robustness to adversarial attack, advancing the state of the art in this field.
+
+# 2 INPUT DISCRETIZATION
+
+We propose to break the linear extrapolation behavior of machine learning models by preprocessing the input with an extremely nonlinear function. This function must still permit the machine learning model to function successfully on naturally occurring inputs. The recent success of the PixelRNN model (Oord et al., 2016) has demonstrated that one-hot discrete codes for 256 possible values of color pixels are effective representations for input data. Other extremely nonlinear functions may also defend against adversarial examples, but we focused attention on vector-valued discrete encoding as our nonlinear function because of the evidence from PixelRNN that it would support successful machine learning.
+
+Images are often encoded as a 3D tensor of integers in the range [0, 255]. The tensor’s three dimensions correspond to the image’s height, width, and color channels (e.g. three for RGB, one for greyscale). Each value represents an intensity value for a given color at a given horizontal/vertical position. For classification tasks, these values are typically normalized to floating-point approximations in the range (0, 1). Input discretization refers to the process of separating these continuousvalued pixel inputs into a set of non-overlapping buckets, which are each mapped to a fixed binary vector.
+
+Past work, for example depth-color-squeezing (Xu et al., 2017), has explored what we will refer to as quantization of inputs as a potential defense against adversarial examples. In that approach, each pixel value is mapped to the low-bit version of its original value, which is a fixed scalar. The key novel aspect of our approach is that rather than replacing a real number with a number of low bit depth, we replace each real number with a binary vector. Different values of the real number activate different bits of the input vector. Multiplying the input vector by the network’s weights thus performs an operation similar to an embedding lookup in a language model, so different input values actually use different parameters of the network. To avoid confusion, we will consistently refer to scalar-toscalar precision reduction as quantization and scalar-to-vector encoding schemes as discretization throughout this work. A comparison of these techniques can be seen in Table 1. Note that, unlike depth-color-squeezing, discretization makes a meaningful change to the model, even when it is configured to use enough discretization levels to avoid losing any information from a traditionally formatted computer vision training set; discretizing each pixel to 256 levels will preserve all of the information contained in the original image. Discretization defends against adversarial examples by changing which parameters of the model are used, and may also discard information if the number of discretization levels is low; quantization can only defend the model by discarding information.
+
+<table><tr><td>Real-valued</td><td>Quantized</td><td>Discretized (one-hot)</td><td>Discretized (thermometer)</td></tr><tr><td>0.13</td><td>0.15</td><td>[0100000000]</td><td>[0111111111]</td></tr><tr><td>0.66</td><td>0.65</td><td>[0000001000]</td><td>[0000001111]</td></tr><tr><td>0.92</td><td>0.95</td><td>[0000000001]</td><td>[0000000001]</td></tr></table>
+
+Table 1: Examples mapping from continuous-valued inputs to quantized inputs, one-hot codes, and thermometer codes, with ten evenly-spaced levels.
+
+# 2.1 DISCRETIZATION AS A DEFENSE
+
+In Goodfellow et al. (2014), the authors provide evidence that several network architectures, including LSTMs (Hochreiter & Schmidhuber, 1997), sigmoid networks (Han & Moraga, 1995), and maxout networks (Goodfellow et al., 2013), are vulnerable to adversarial examples due to the empirical fact that, when trained, the loss function of these networks tends to be highly linear with respect to its inputs.
+
+We briefly recall the reasoning of Goodfellow et al. (2014). Assume that we have a logistic regressor with weight matrix $w$ . Consider an image $x \in \mathbb { R } ^ { n }$ which is perturbed into $\widetilde { x } = x + \eta$ by some noise $\eta$ such that $\| \eta \| _ { \infty } \le \varepsilon$ for some $\varepsilon$ . The probability that the model assigns to the true class is equal to:
+
+$$
+\mathbb { L } ( \widetilde { \boldsymbol { x } } ) = \sigma ( \boldsymbol { w } ^ { \top } \widetilde { \boldsymbol { x } } ) = \sigma ( \boldsymbol { w } ^ { \top } ( \boldsymbol { x } + \boldsymbol { \eta } ) ) = \sigma ( \boldsymbol { w } ^ { \top } \boldsymbol { x } + \boldsymbol { w } ^ { \top } \boldsymbol { \eta } )
+$$
+
+If the perturbation $\eta$ is adversarial, such as in the case where $\begin{array} { r } { \eta _ { i } : = \varepsilon \cdot \mathrm { s i g n } \left( \frac { \partial \mathbb { L } ( x ) } { \partial x _ { i } } \right) } \end{array}$ , then the input to the sigmoid is increased by $\varepsilon \cdot n$ . If $n$ is large, as is typically the case in images and other highdimensional spaces of interest, this linearity implies that even imperceptibly small values of $\varepsilon$ can have a large effect on the model’s prediction, making the model vulnerable to adversarial attacks.
+
+Though neural networks in principle have the capacity to represent highly nonlinear functions, networks trained via stochastic gradient descent on real-world datasets tend to converge to mostly-linear solutions. This is illustrated in the empirical studies conducted by Goodfellow et al. (2014). One hypothesis proposed to explain this phenomenon is that the nonlinearities typically used in networks are either piecewise linear, like ReLUs, or approximately linear in the parts of their domain in which training takes place, like the sigmoid function.
+
+One potential solution to this problem is to use more non-linear activation functions, such as quadratic or RBF units. Indeed, it was shown by Goodfellow et al. (2014) that such units were more resistant to adversarial perturbations of their inputs. However, these units are difficult to train, and the resulting models do not generalize very well (Goodfellow et al., 2014), sacrificing accuracy on clean examples. As an alternative to introducing highly non-linear activation functions in the network, we propose applying a non-differentiable and non-linear transformation (discretization) to the input, before passing it into the model. A comparison of the input to the model under various regimes can be seen in Figure 1, highlighting the strong non-linearity of discretization techniques.
+
+![](images/1babc487bea1da3867ddd67e758440fd4bfd2a7dd066a336fbbff60b9365e8fd.jpg)  
+Figure 1: Comparison of regular inputs, quantized inputs, and discretized inputs (16 levels, projected to one dimension) on MNIST, adversarially trained with $\varepsilon = 0 . 3$ . The $x$ -axis represents the true pixel value of the image, and the $y$ -axis represents the value that is passed as input to the network after the input transformation has been applied. For real-valued inputs, the inputs to the network are affected linearly by perturbations to the input. Quantized inputs are also affected approximately linearly by perturbations where $\varepsilon$ is greater than the bucket width. Discretizing the input, and then using learned weights to project the discretized value back to a single scalar, we see that the model has learned a highly non-linear function to represent the input in a fashion that is effective for resisting the adversarial perturbations it has seen. When starting at the most common pixel-values for MNIST, 0 and 1, any perturbation of the pixels (where $\varepsilon \le 0 . 3 )$ ) has barely any effect on the input to the network.
+
+# 2.2 TYPES OF DISCRETIZATION
+
+In this work we consider two approaches to constructing discretized representations $f ( x )$ of the input image $x$ . Assume for the sake of simplicity that the entries of $x$ take values in the continuous domain $[ 0 , 1 ]$ .
+
+We first describe a quantization function $b$ . Choose $0 < b _ { 1 } < b _ { 2 } < \cdot \cdot \cdot < b _ { k } = 1$ in some fashion. (In this work, we simply divide the domain evenly, i.e. $\begin{array} { r } { b _ { i } = \frac { i } { k } } \end{array}$ .) For a real number $\theta \in [ 0 , 1 ]$ define $b ( \theta )$ to be the largest index $\alpha \in \{ 1 , \ldots , k \}$ such that $\theta \leq b _ { \alpha }$ .
+
+# 2.2.1 ONE-HOT ENCODINGS
+
+For an index $j \in \{ 1 , \ldots , k \}$ let $\chi ( j ) \in \mathbb { R } ^ { k }$ be the indicator or one-hot vector of $j$ , i.e.,
+
+$$
+\chi ( j ) _ { l } = { \left\{ \begin{array} { l l } { 1 } & { { \mathrm { i f ~ } } l = j } \\ { 0 } & { { \mathrm { o t h e r w i s e . } } } \end{array} \right. }
+$$
+
+The discretization function is defined pixel-wise for a pixel $i \in \{ 1 , \ldots , n \}$ as:
+
+$$
+f _ { o n e h o t } ( x _ { i } ) = \chi \left( b ( x _ { i } ) \right) .
+$$
+
+One-hot encodings are simple to compute and understand, and are often used when it is necessary to represent a categorical variable in a neural network. However, one-hot encodings are not well suited for representing categorical variables with an interpretation of ordering between them. Note that the ordering information between two pixels $x _ { i }$ and $x _ { j }$ is lost by applying the transformation $f _ { o n e h o t }$ ; for a pair of pixels $i , j$ whenever $b ( x _ { i } ) \neq b ( x _ { j } ) )$ , we see:
+
+$$
+\| \chi ( b ( x _ { i } ) ) \| _ { 2 } = \| \chi ( b ( x _ { j } ) ) \| _ { 2 } = 1 .
+$$
+
+In the case of pixel values, this is not a good inductive bias, as there is a clear reason to believe that neighboring buckets are more similar to each other than distant buckets.
+
+# 2.2.2 THERMOMETER ENCODINGS
+
+In order to discretize the input image $x$ without losing the relative distance information, we propose thermometer encodings. For an index $j \in \{ 1 , \ldots , k \}$ , let $\tau ( j ) \in \mathbb { R } ^ { k }$ be the thermometer vector defined as
+
+$$
+\tau ( j ) _ { l } = { \left\{ \begin{array} { l l } { 1 } & { { \mathrm { i f ~ } } l \geq j } \\ { 0 } & { { \mathrm { o t h e r w i s e . } } } \end{array} \right. }
+$$
+
+Then the discretization function $f$ is defined pixel-wise for a pixel $i \in \{ 1 , \ldots , n \}$ as:
+
+$$
+f _ { t h e r m } ( x ) _ { i } = \tau \left( b ( x _ { i } ) \right) = \mathbb { C } ( f _ { o n e h o t } ( x _ { i } ) )
+$$
+
+where $\mathbb { C }$ is the cumulative sum function, $\mathbb { C } ( c ) _ { l } = \sum _ { j = 0 } ^ { l } c _ { l }$
+
+Note that the thermometer encoding preserves pairwise ordering information, i.e., for pixels $i , j$ if $b ( x _ { j } ) \neq b ( x _ { k } )$ and $x _ { i } < x _ { j }$ then
+
+$$
+\left\| \tau ( b ( x _ { i } ) ) \right\| _ { 2 } < \left\| \tau ( b ( x _ { j } ) ) \right\| _ { 2 } .
+$$
+
+# 2.3 WHITE-BOX ATTACKS ON DISCRETIZED INPUTS
+
+Discretizing the input makes it difficult to attack the model with standard white-box attack algorithms, such as FGSM (Goodfellow et al., 2014) and PGD (Madry et al., 2017), since it is impossible to backpropagate through our discretization function to determine how to adversarially modify the model’s input. In this section, we describe two novel iterative attacks which allow us to construct adversarial examples for networks trained on discretized inputs.
+
+Constructing white-box attacks on discretized inputs serves two primary purposes. First, it allows us to more completely evaluate whether the model is robust to all adversarial attacks, as white-box attacks are typically more powerful than their black-box counterparts. Secondly, adversarial training is typically performed in a white-box fashion, and so in order to utilize and properly compare against the adversarial training techniques of Madry et al. (2017), it is important to have strong white-box attacks.
+
+For ease of presentation, we will describe the attacks assuming that $f : \mathbb { R } \to \mathbb { R } ^ { k }$ discretizes inputs into thermometer encodings; in order to attack one-hot encodings, simply replace all instances of $f _ { t h e r m }$ with $f _ { o n e h o t }$ , $\tau$ with $\chi$ , and $\mathbb { C }$ with the identity function I. We represent the adversarial image after $t$ steps of the attack as $z ^ { t }$ , where the value of the ith pixel is $z _ { i } ^ { t }$ .
+
+The first attack, Discrete Gradient Ascent (DGA), follows the direction of the gradient of the loss with respect to $f ( x )$ , but is constrained at every step to be a discretized vector. If we have discretized the input image into $k$ -dimensional vectors using the one-hot encoding, this corresponds to moving to a vertex of the simplex $\left( \Delta _ { k } \right) ^ { n }$ at every step. The second attack, Logit-Space Projected Gradient Ascent (LS-PGA), relaxes this assumption, allowing intermediate iterates to be in the interior of the simplex. The final adversarial image is obtained by projecting the final point back to the nearest vertex of the simplex.
+
+Note that if the number of attack steps is 1, then the two attacks are equivalent; however, for larger numbers of attack steps, LS-PGA is a generalization of DGA.
+
+# 2.3.1 DISCRETE GRADIENT ASCENT (DGA)
+
+Following PGD (Madry et al., 2017), we initialize DGA by placing each pixel into a random bucket that is within $\varepsilon$ of the pixel’s true value. At each step of the attack, we look at all buckets that are within $\varepsilon$ of the true value, and select the bucket that is likely to do the most ‘harm’, as estimated by the gradient of setting that bucket’s indicator variable to 1, with respect to the model’s loss at the previous step.
+
+$$
+\begin{array} { r l } & { z _ { i } ^ { 0 } = f _ { t h e r m } ( x _ { i } + U ( - \varepsilon , \varepsilon ) ) } \\ & { \mathrm { h a r m } ( z _ { i } ^ { t } ) _ { l } = \left\{ \begin{array} { l l } { ( z _ { i } ^ { t } - \tau ( l ) ) ^ { \top } \cdot \frac { \partial \mathbb { L } ( z ^ { t } ) } { \partial z _ { i } ^ { t } } } & { \mathrm { i f } \exists ( - \varepsilon \leq \eta \leq \varepsilon ) \quad \mathrm { s . t . } \quad b ( x _ { i } + \eta ) = l } \\ { 0 } & { \mathrm { o t h e r w i s e . } } \end{array} \right. } \\ & { \qquad z _ { i } ^ { t + 1 } = \tau \left( \mathrm { a r g } \operatorname* { m a x } \left( \mathrm { h a r m } \left( z _ { i } ^ { t } \right) \right) \right) } \end{array}
+$$
+
+Because the outcome of this optimization procedure will vary depending on the initial random perturbation, we suggest strengthening the attack by re-running it several times and using the perturbation with the greatest loss. The pseudo-code for the DGA attack is given in Section $\mathbf { B }$ of the appendix.
+
+# 2.3.2 LOGIT-SPACE PROJECTED GRADIENT ASCENT (LS-PGA)
+
+To perform LS-PGA, we soften the discrete encodings into continuous relaxations, and then perform standard Projected Gradient Ascent (PGA) on these relaxed values. We represent the distribution over embeddings as a softmax over logits $u$ , each corresponding to the unnormalized log-weight of a specific bucket’s embedding. To improve the attack, we scale the logits with temperature $T$ , allowing us to trade off between how closely our softmax approximates a true one-hot distribution as in the Gumbel-softmax trick (Jang et al., 2016; Maddison et al., 2016), and how much gradient signal the logits receive. At each step of a multi-step attack, we anneal this value via exponential decay with rate $\delta$ .
+
+$$
+\begin{array} { c } { { z _ { i } ^ { t } = \mathbb C \left( \sigma \left( \frac { u _ { i } ^ { t } } { T ^ { t } } \right) \right) } } \\ { { z _ { i } ^ { f i n a l } = \tau \left( \arg \operatorname* { m a x } \left( u _ { i } ^ { f i n a l } \right) \right) } } \\ { { T ^ { t } = T ^ { t - 1 } \cdot \delta } } \end{array}
+$$
+
+We initialize each of the logits randomly with values sampled from a standard normal distribution. At each step, we ensure that the model does not assign any probability to buckets which are not within $\varepsilon$ of the true value by fixing the logits to be $- \infty$ . The model’s loss is a continuous function of the logits, so we can simply utilize attacks designed for continuous-valued inputs, in this case PGA
+
+with step-size $\xi$ .
+
+$$
+\begin{array} { r l } & { u _ { i } ^ { 0 } = \left\{ \begin{array} { l l } { N \left( \mathbf { 0 } ; \mathbf { 1 } \right) } & { \mathrm { i f ~ } \exists ( - \varepsilon \leq \eta \leq \varepsilon ) \quad \mathrm { s . t . } \quad b ( x _ { i } + \eta ) = l } \\ { - \infty } & { \mathrm { o t h e r w i s e . } } \end{array} \right. } \\ & { \left( u _ { i } ^ { t + 1 } \right) _ { l } = \left\{ \begin{array} { l l } { \left( u _ { i } ^ { t } \right) _ { l } + \xi \cdot \mathrm { s i g n } \left( \frac { \partial \mathbb { L } \left( z ^ { t } \right) } { \partial u _ { i } ^ { t } } \right) _ { l } } & { \mathrm { i f ~ } \exists ( - \varepsilon \leq \eta \leq \varepsilon ) \quad \mathrm { s . t . } \quad b ( x _ { i } + \eta ) = l } \\ { - \infty } & { \mathrm { o t h e r w i s e . } } \end{array} \right. } \end{array}
+$$
+
+Because the outcome of this optimization procedure will vary depending on the initial perturbation, we suggest strengthening the attack by re-running it several times and using the perturbation with the greatest loss. The pseudo-code for the LS-PGA attack is given in Section B of the appendix.
+
+# 3 EXPERIMENTS
+
+We compare models trained with input discretization to state-of-the-art adversarial defenses on a variety of datasets. We match the experimental setup of the prior literature as closely as possible. Rows labeled with “Vanilla (Madry)” give the numbers reported in Madry et al. (2017); other rows contain results of our own experiments, with “Vanilla” containing a direct replication. For our MNIST experiments, we use a convolutional network; for CIFAR-10, CIFAR-100, and SVHN we use a Wide ResNet (Zagoruyko & Komodakis, 2016). We use a network of depth 30 for the CIFAR10 and CIFAR-100 datasets, while for SVHN we use a network of depth 15. The width factor of all the Wide ResNets is set to $k = 4$ . 1 Unless otherwise specified, all quantized and discretized models use 16 levels.
+
+We found that in all cases, LS-PGA was strictly more powerful than DGA, so all attacks on discretized models use LS-PGA with $\xi = 0 . 0 1 , \delta = 1 . 2$ , and 1 random restart. To be consistent with Madry et al. (2017), we describe attacks in terms of the maximum $\ell _ { \infty }$ -norm of the attack, $\varepsilon$ . All MNIST experiments used $\varepsilon = 0 . 3$ and 40 steps for iterative attacks; experiments on CIFAR used $\varepsilon = 0 . 0 3 1$ and 7 steps for iterative attacks; experiments on SVHN used $\varepsilon = 0 . 0 4 7$ and 10 steps for iterative attacks. These settings were used for adversarial training, white-box attacks, and blackbox attacks. Figure 3 plots the effectiveness of the iterated PGD/LS-PGA attacks on vanilla and discretized models for MNIST and shows that increasing the number of iterations beyond 40 would have no effect on the performance of the model on $\ell _ { \infty }$ -bounded adversarial examples for MNIST.
+
+In Madry et al. (2017), adversarially-trained models are trained using exclusively adversarial inputs. This led to a small but noticeable loss in accuracy on clean examples, dropping from $9 9 . 2 \%$ to $9 8 . 8 \%$ on MNIST and from $9 5 . 2 \%$ to $8 7 . 3 \%$ on CIFAR-10 in return for more robustness towards adversarial examples. Past work has also sometimes performed adversarial training on batches composed of half clean examples and half adversarial examples (Goodfellow et al., 2014; Cisse et al., 2017). To be consistent with Madry et al. (2017), we list experiments on models trained only on adversarial inputs in the main paper; additional experiments on a mix of clean and adversarial inputs can be found in the appendix.
+
+We also run experiments exploring the model’s relationship with the number of distinct levels to which we quantize the input before discretizing it, and exploring various settings of hyperparameters for LS-PGA.
+
+# 4 RESULTS
+
+Our adversarially-trained baseline models were able to approximately replicate the results of Madry et al. (2017). On all datasets, discretizing the inputs of the network dramatically improves resistance to adversarial examples, while barely sacrificing any accuracy on clean examples. Quantized models also beat the baseline, but with lower accuracy on clean examples. Discretization via thermometer encodings outperformed one-hot encodings in most settings. See Tables 2,3,4 and 5 for results on MNIST and CIFAR-10. Additional results on CIFAR-100 and SVHN are included in the appendix.
+
+In Figures 2 and 5 (located in appendix), we plot the test-set accuracy across training timesteps for various adversarially trained models on the SVHN and CIFAR-10 datasets, and observe that the discretized models become robust against adversarial examples more quickly.
+
+Table 2: Comparison of adversarial robustness to white-box attacks on MNIST .   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>PGD/LS-PGA</td></tr><tr><td rowspan=2 colspan=1>ereaa</td><td rowspan=2 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=2 colspan=1>99.2099.3099.1999.1399.20</td><td rowspan=1 colspan=1>6.40</td><td rowspan=2 colspan=1>-0000</td></tr><tr><td rowspan=1 colspan=1>0.191.1000</td></tr><tr><td rowspan=3 colspan=1>Y1nit apt</td><td rowspan=3 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=3 colspan=1>98.8098.6798.7598.6199.03</td><td rowspan=1 colspan=1>95.6096.1796.29</td><td rowspan=3 colspan=1>93.2093.3094.2394.3094.02</td></tr><tr><td rowspan=1 colspan=1>96.22</td></tr><tr><td rowspan=1 colspan=1>95.84</td></tr></table>
+
+Table 3: Comparison of adversarial robustness to black-box attacks on MNIST .   
+
+<table><tr><td colspan="2" rowspan="2">Source Target</td><td rowspan="2"></td><td colspan="3">Clean</td><td colspan="3">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td rowspan="3">Ereaa</td><td rowspan="3">Vanilla Quantized One-hot</td><td>2.04</td><td>36.02</td><td>24.58</td><td>3.48</td><td>80.44</td><td>57.69</td></tr><tr><td>39.22</td><td>32.39</td><td>25.63</td><td>75.02</td><td>75.92</td><td>52.32</td></tr><tr><td>14.57</td><td>6.91</td><td>8.11</td><td>39.02</td><td>39.60</td><td>18.02</td></tr><tr><td rowspan="6">11p1l Apv</td><td rowspan="6">Thermometer Vanilla (Madry)</td><td>41.12</td><td>14.30</td><td>10.98</td><td>61.84</td><td>59.16</td><td>32.93</td></tr><tr><td>=</td><td></td><td>1</td><td>96.0</td><td>=</td><td>1</td></tr><tr><td>Quantized</td><td>97.65</td><td>98.16</td><td>97.14</td><td>95.27 95.31</td><td>96.53</td></tr><tr><td>Vanilla One-hot</td><td>97.62</td><td>98.05</td><td>97.06 95.43</td><td>95.38</td><td>96.23</td></tr><tr><td>97.78</td><td>98.48</td><td>97.87</td><td>96.87</td><td>96.60</td><td>96.87</td></tr><tr><td>Thermometer 98.07</td><td>98.75</td><td>98.02</td><td>97.05</td><td>96.88</td><td>97.13</td></tr></table>
+
+Table 4: Comparison of adversarial robustness to white-box attacks on CIFAR-10 .   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>PGD/LS-PGA</td></tr><tr><td rowspan=2 colspan=1>eeeaa</td><td rowspan=2 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=2 colspan=1>95.2094.2993.4993.2694.22</td><td rowspan=1 colspan=1>25.10</td><td rowspan=2 colspan=1>4.101.663.5753.1150.50</td></tr><tr><td rowspan=1 colspan=1>46.1543.8952.0748.50</td></tr><tr><td rowspan=1 colspan=1>11p11 &#x27;Apv</td><td rowspan=1 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=1 colspan=1>87.387.6785.7588.6789.88</td><td rowspan=1 colspan=1>60.359.753.5368.7680.96</td><td rowspan=1 colspan=1>50.041.7842.0967.8379.16</td></tr></table>
+
+# 5 DISCUSSION
+
+In Goodfellow et al. (2014), the seeming linearity of deep neural networks was shown by visualizing the networks in several different ways. To test our hypothesis that discretization breaks some of this linearity, we replicate these visualizations and contrast them to visualizations of discretized models. See Appendix G for an illustration of these properties.
+
+For non-discretized, clean trained models, test-set examples always yield a linear boundary between correct and incorrect classification; in contrast, non-adversarially-trained models have a more interesting parabolic shape (see Figure 9).
+
+Table 5: Comparison of adversarial robustness to black-box attacks on CIFAR-10 .   
+
+<table><tr><td colspan="2" rowspan="2">Source Target</td><td rowspan="2"></td><td colspan="3">Clean</td><td colspan="3">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td rowspan="4">evaa</td><td>Vanilla (Madry)</td><td>0.0</td><td>1</td><td>1</td><td>79.7</td><td>1</td><td>1</td></tr><tr><td>Vanilla</td><td>3.38</td><td>60.10</td><td>52.60</td><td>45.48</td><td>37.21</td><td>49.91</td></tr><tr><td>Quantized</td><td>70.54</td><td>62.46</td><td>55.38</td><td>51.74</td><td>45.37</td><td>55.64</td></tr><tr><td>One-hot</td><td>83.00</td><td>56.25</td><td>63.94</td><td>54.59</td><td>49.21</td><td>57.28</td></tr><tr><td rowspan="5">11pl apa</td><td>Thermometer Vanilla (Madry)</td><td>80.33</td><td>66.22</td><td>53.45</td><td>57.04</td><td>51.03</td><td>60.90</td></tr><tr><td></td><td>85.60</td><td>1</td><td>1</td><td>67.0</td><td>1</td><td>1</td></tr><tr><td>Vanilla</td><td>85.60</td><td>74.99</td><td>73.78</td><td>67.0</td><td>50.09</td><td>71.03</td></tr><tr><td>Quantized</td><td>84.56</td><td>82.43</td><td>82.22</td><td>72.52</td><td>72.29</td><td>79.43</td></tr><tr><td>One-hot Thermometer</td><td>86.01 88.25</td><td>77.19 81.59</td><td>77.70 80.80</td><td>61.92 67.96</td><td>60.02 67.43</td><td>72.89 77.68</td></tr></table>
+
+![](images/2bf62500dea56cf3c5583933ce283039d15429aef2ff7e82327b7f820baa6c41.jpg)  
+Figure 2: Comparison of the convergence rate of various adversarially trained models on the SVHN dataset.
+
+![](images/7bd4936771b204f572b896b319647e0cafa645e72147b75f92d688d6fe438bbe.jpg)  
+Figure 3: Loss for iterated white-box attacks on various models on a randomly chosen data point from MNIST. By step 40, which is where we evaluate, the loss of the point found by iterative attacks has converged.
+
+When discretizing the input, we introduce $C _ { w } \cdot C _ { h } \cdot C _ { o } \cdot c \cdot ( k - 1 )$ extra parameters, where $c$ is the number of channels in the image, $k$ is the number of levels of discretization, and $C _ { w } , C _ { h } , C _ { o }$ are the width, height, and output channels of the first convolutional layer. Discretizing using 16 levels introduced $0 . 0 3 \%$ extra parameters for MNIST, $0 . 0 8 \%$ for CIFAR-10 and CIFAR-100, and $2 . 3 \%$ for SVHN. This increase is negligible, so it is likely that the robustness comes from the input discretization, and is not merely a byproduct of having a slightly higher-capacity model.
+
+# 6 CONCLUSION
+
+Our findings convincingly demonstrate that the use of thermometer encodings, in combination with adversarial training, can reduce the vulnerability of neural network models to adversarial attacks. Our analysis reveals that the resulting networks are significantly less linear with respect to their inputs, supporting the hypothesis of Goodfellow et al. (2014) that many adversarial examples are caused by over-generalization in networks that are too linear.
+
+# REFERENCES
+
+Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013.
+
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In International Conference on Machine Learning, pp. 854–863, 2017.
+
+Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. arXiv preprint arXiv:1302.4389, 2013.
+
+Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014.
+
+Jun Han and Claudio Moraga. The influence of the sigmoid function parameters on the speed of backpropagation learning. From Natural to Artificial Neural Computation, pp. 195–201, 1995.
+
+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.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In European Conference on Computer Vision, pp. 646–661. Springer, 2016.
+
+Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016.
+
+Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016.
+
+Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013.
+
+Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. CoRR, abs/1611.02770, 2016. URL http://arxiv.org/abs/ 1611.02770.
+
+Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016.
+
+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.
+
+Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016.
+
+Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. ICLR, abs/1312.6199, 2014. URL http://arxiv.org/abs/1312.6199.
+
+Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017.
+
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.
+
+# A HYPERPARAMETERS
+
+In this section, we describe the hyperparameters used in our experiments. For CIFAR-10 and CIFAR-100 we follow the standard data augmenting scheme as in (Lin et al., 2013; He et al., 2016; Huang et al., 2016; Zagoruyko & Komodakis, 2016): each training image is zero-padded with 4 pixels on each side and randomly cropped to a new $3 2 \times 3 2$ image. The resulting image is randomly flipped with probability 0.5, it’s brightness is adjusted with a delta chosen uniformly at random in the interval $[ - 6 3 , 6 3 )$ and it’s contrast is adjusted using a random contrast factor in the interval [0.2, 1.8]. For MNIST we use the Adam optimizer with a fixed learning rate of $1 \mathrm { e } { - 4 }$ as in Madry et al. (2017). For CIFAR-10 and CIFAR-100 we use the Momentum optimizer with momentum 0.9, $\ell _ { 2 }$ weight decay of $\lambda = 0 . 0 0 0 5$ and an initial learning rate of 0.1 which is annealed by a factor of 0.2 after epochs 60, 120 and 160 respectively as in Zagoruyko & Komodakis (2016). For SVHN we use the same optimizer with initial learning rate of $\mathrm { 1 e { - } 2 }$ which is annealed by a factor of 0.1 after epochs 80 and 120 respectively. We also use a dropout of 0.3 for CIFAR-10, CIFAR-100 and SVHN.
+
+# B PSEUDO-CODE
+
+The DGA attack is described in Algorithm 2 and the LS-PGA attack is described in Algorithm 3.   
+Both these algorithms make use of a getM ask() sub-routine which is described in Algorithm 1.
+
+<table><tr><td></td><td>Input: Image x, parameter ε</td></tr><tr><td></td><td>Output: ε-discretized mask around x</td></tr><tr><td>2</td><td>mask ← (0)nxk</td></tr><tr><td>3</td><td>low ← max{0,x - ε}</td></tr><tr><td>4</td><td>high ← min{1,𝑥 +ε}</td></tr><tr><td>5</td><td>for α←O to1by do</td></tr><tr><td>6</td><td>mask ← mask+ fonehot (α * low + (1- α) * high) end</td></tr><tr><td>7</td><td>return mask</td></tr><tr><td></td><td></td></tr></table>
+
+Algorithm 1: Sub-routine for getting an $\varepsilon$ -discretized mask of an image.
+
+# C ADDITIONAL EXPERIMENTS ON MNIST
+
+In this section we list the additional experiments we performed using discretized models on MNIST. The main hyperparameters of Algorithm 3 are the step size $\xi$ used to perform the projected gradient ascent, and the annealing rate of $\delta$ . We found that the choice of these hyperparameters was not critical to the robustness of the model. In particular, we performed experiments with $\xi = 1 . 0$ and $\xi = 0 . 0 0 1$ , and both achieved similar accuracies as in Table 2 and Table 3. Additionally, we found that without annealing, i.e., $\delta = 1 . 0$ , the performance was only slightly worse than with $\delta = 1 . 2$ .
+
+We also experimented with discretizing by using percentile information per color channel instead of using uniformly distributed buckets. This did not result in any significant changes in robustness or accuracy for the MNIST dataset.
+
+Input: Image $x$ , label $y$ , discretization function $f$ , loss $\mathbb { L } ( \pmb \theta , f ( x ) , y )$ , l attack steps, parameter $\varepsilon$ Output: Adversarial input to the network $z ^ { \prime }$ 1 $\eta  U ( - \varepsilon , \varepsilon )$ $ { \vert z _ { 0 } \gets f ( x + \dot { \eta } ) }$ 3 $\mathrm { m a s k }  g e t M a s k ( x , \varepsilon )$ for $t \gets 1$ to $l$ do $/ \star$ Loop invariant: $z _ { i } ^ { t }$ is discretized for every pixel i \*/ 5 $\mathrm { g r a d }  \nabla _ { z ^ { t - 1 } } \mathbb { L } ( \pmb \theta , z ^ { t - 1 } , y )$ 6 if $f$ is one-hot then 7 $\mathrm { h a r m } _ { l } \gets ( z ^ { t - 1 } - \chi ( l ) ) ^ { \top } \mathrm { g r a d }$ 8 else 9 $\vert \quad \mathrm { h a r m } _ { l } \gets ( z ^ { t - 1 } - \tau ( l ) ) ^ { \top } \mathrm { g r a d }$ 10 end 11 $\mathrm { h a r m } \gets \mathrm { h a r m } * \mathrm { m a s k } - ( 1 - \mathrm { m a s k } ) * \infty$ 12 zt ← f (arg max(harm)) 13 end 14 return z0 ← zl
+
+Input: Image $x$ , label $y$ , discretization function $f$ , loss $\mathbb { L } ( \pmb \theta , f ( x ) , y )$ , $l$ attack steps, parameters ε, δ Output: Adversarial input to the network $z ^ { \prime }$ $\mathrm { m a s k }  g e t M a s k ( x , \varepsilon )$ $u ^ { 0 } \gets \left( \mathcal { N } ( \mathbf { 0 } ^ { k } ; \mathbf { 1 } ^ { k } ) \right) ^ { n } * \mathrm { m a s k - } \left( 1 - \mathrm { m a s k } \right) * \infty$ 3 T ← 1 if $f$ is one-hot then 5 F ← I 6 else 7 F ← C 8 8 end 9 z 0 ← F  σ  u 0T  10 for $t \gets 1$ to $l$ do 11 grad ← ∇ut−1 L(θ, zt−1, y) 12 ut ← ut−1 + ξ · sign (grad) 13 z t ← F  σ  u tT  14 T ← T · δ 15 end 16 return $z ^ { \prime } \gets \tau ( \arg \operatorname* { m a x } ( u _ { i } ^ { l } ) )$
+
+Algorithm 2: Discrete Gradient Ascent (DGA)   
+Algorithm 3: Logit-Space Projected Gradient Ascent (LS-PGA)   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>m</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>White-box</td><td rowspan=1 colspan=1>Black-box</td></tr><tr><td rowspan=1 colspan=1>One-hotOne-hotOne-hot</td><td rowspan=1 colspan=1>1.00.0011.0</td><td rowspan=1 colspan=1>1.21.21.0</td><td rowspan=1 colspan=1>93.0893.5093.02</td><td rowspan=1 colspan=1>98.3998.4298.21</td></tr><tr><td rowspan=1 colspan=1>ThermometerThermometerThermometer</td><td rowspan=1 colspan=1>1.00.0011.0</td><td rowspan=1 colspan=1>1.21.21.0</td><td rowspan=1 colspan=1>93.7493.8893.75</td><td rowspan=1 colspan=1>98.4598.2498.22</td></tr></table>
+
+Table 6: Comparison of adversarial robustness to white-box attacks on MNIST using 16 levels and with various choices of the hyperparameters $\xi$ and $\delta$ for Algorithm 3. The models are evaluated on white-box attacks and on black-box attacks using a vanilla, clean trained model; both use LS-PGA.
+
+Finally, we also trained on a mix of clean and adversarial examples: this resulted in significantly higher accuracy on clean examples, but decreased accuracy on white-box and black-box attacks compared to Tables 2 and 3.
+
+<table><tr><td>Model</td><td>Clean</td><td>FGSM</td><td>PGD/LS-PGA</td></tr><tr><td>Vanilla</td><td>99.03</td><td>95.70</td><td>91.36</td></tr><tr><td>One-hot</td><td>99.01</td><td>96.14</td><td>93.77</td></tr><tr><td>Thermometer</td><td>99.13</td><td>96.10</td><td>93.70</td></tr></table>
+
+Table 7: Comparison of adversarial robustness to white-box attacks on MNIST using a mix of clean and adversarial examples.
+
+<table><tr><td rowspan="2">Source Target</td><td colspan="3">Clean</td><td colspan="3">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td>Vanilla</td><td>97.88</td><td>97.87</td><td>96.99</td><td>93.07</td><td>90.97</td><td>96.46</td></tr><tr><td>One-hot</td><td>98.28</td><td>98.83</td><td>98.08</td><td>95.73</td><td>95.96</td><td>97.25</td></tr><tr><td>Thermometer</td><td>98.45</td><td>98.70</td><td>98.08</td><td>96.35</td><td>95.72</td><td>96.97</td></tr></table>
+
+Table 8: Comparison of adversarial robustness to black-box attacks on MNIST of various models using a mix of clean and adversarial examples.
+
+<table><tr><td></td><td></td><td>White-box</td><td colspan="2">Black-box</td></tr><tr><td>Levels</td><td>Clean</td><td>PGD/LS-PGA</td><td>Vanilla, Clean</td><td>Vanilla, PGD</td></tr><tr><td>One-hot (4) One-hot (8) One-hot (16)</td><td>99.09 99.10 99.14</td><td>92.95 92.65 93.08</td><td>98.23 98.49 98.39</td><td>95.64 96.37</td></tr><tr><td>One-hot (32) One-hot (64)</td><td>99.06 98.89</td><td>93.51 93.63</td><td>98.38 98.35</td><td>96.26 95.78</td></tr><tr><td>Thermometer (4)</td><td></td><td></td><td></td><td>95.74</td></tr><tr><td></td><td>99.11</td><td>92.62</td><td>98.23</td><td>95.67</td></tr><tr><td>Thermometer (8)</td><td>99.08</td><td>93.45</td><td>98.44</td><td>95.93</td></tr><tr><td>Thermometer(16)</td><td>99.07</td><td>93.88</td><td>98.24</td><td>95.28</td></tr><tr><td>Thermometer (32)</td><td>99.02</td><td>94.14</td><td>98.24</td><td>95.49</td></tr><tr><td>Thermometer (64)</td><td>99.00</td><td>94.62</td><td>98.33</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>95.71</td></tr></table>
+
+Table 9: Comparison of adversarial robustness on MNIST as the number of levels of discretization is varied. All models are trained mix of adversarial examples and clean examples.
+
+# D ADDITIONAL EXPERIMENTS ON CIFAR-10
+
+In this section we list the additional experiments we performed on CIFAR-10. Firstly, we trained models on a mix of both clean and adversarial examples. The results for mixed training are listed in Tables 10 and 11; as expected it has lower accuracy on adversarial examples, but higher accuracy on clean examples, compared to training on only adversarial examples (Tables 4 and 5).
+
+<table><tr><td>Model</td><td>Clean</td><td>FGSM</td><td>PGD/LS-PGA</td></tr><tr><td>Vanilla</td><td>87.16</td><td>54.50</td><td>34.71</td></tr><tr><td>One-hot</td><td>92.19</td><td>58.87</td><td>58.96</td></tr><tr><td>Thermometer</td><td>92.32</td><td>66.60</td><td>65.67</td></tr></table>
+
+Table 10: Comparison of adversarial robustness to white-box attacks on CIFAR-10 of various models using a mix of regular and adversarial training.
+
+<table><tr><td rowspan="2">Source Target</td><td colspan="3">Clean</td><td colspan="3">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td colspan="2">Vanilla</td><td>83.62</td><td>82.06</td><td>74.31</td><td>52.83</td><td>58.73</td><td>65.24</td></tr><tr><td colspan="2">One-hot</td><td>88.16</td><td>75.11</td><td>75.49</td><td>61.89</td><td>59.17</td><td>69.73</td></tr><tr><td colspan="2">Thermometer</td><td>87.50</td><td>75.91</td><td>74.84</td><td>61.39</td><td>58.51</td><td>68.22</td></tr></table>
+
+Table 11: Comparison of adversarial robustness to black-box attacks on CIFAR-10 of various models using a mix of clean and adversarial examples.
+
+In order to explore whether the number of levels of discretization affected the performance of the model, we trained several models which varied this number. As expected, we found that models with fewer levels had worse accuracy on clean examples, likely because there was not enough information to correctly classify the image, but greater robustness to adversarial examples, likely because larger buckets mean a greater chance that a given perturbation will not yield any change in input to the network (Xu et al., 2017). Results can be seen in Tables 12, and are visualized in Figure 4.
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>White-box</td><td rowspan=1 colspan=2>Black-box</td></tr><tr><td rowspan=1 colspan=1>Levels</td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>PGD/LS-PGA</td><td rowspan=1 colspan=1>Vanilla, Clean</td><td rowspan=1 colspan=1>Vanilla, PGD</td></tr><tr><td rowspan=1 colspan=1>Vanilla (Madry)</td><td rowspan=1 colspan=1>87.3</td><td rowspan=1 colspan=1>50.00</td><td rowspan=1 colspan=1>85.60</td><td rowspan=1 colspan=1>67.00</td></tr><tr><td rowspan=1 colspan=1>One-hot (4)One-hot (8)One-hot (16)One-hot (32)One-hot (64)</td><td rowspan=1 colspan=1>83.6785.6288.5488.5689.63</td><td rowspan=1 colspan=1>59.5961.9867.8367.8265.63</td><td rowspan=1 colspan=1>83.0384.9286.0185.6986.94</td><td rowspan=1 colspan=1>72.0372.1061.9266.6465.77</td></tr><tr><td rowspan=1 colspan=1>Thermometer (4)Thermometer (8)Thermometer (16)Thermometer (32)Thermometer (64)</td><td rowspan=1 colspan=1>84.4785.1789.8890.3089.95</td><td rowspan=1 colspan=1>61.8867.2379.1672.9169.37</td><td rowspan=1 colspan=1>83.6483.4188.2586.0683.85</td><td rowspan=1 colspan=1>72.9671.1167.9659.3251.82</td></tr></table>
+
+Table 12: Comparison of adversarial robustness on CIFAR-10 as the number of levels of discretization is varied. All models are trained only on adversarial examples.
+
+# E EXPERIMENTS ON CIFAR-100
+
+We list the experimental results on CIFAR-100 in Table 13. We choose $\xi = 0 . 0 1$ and $\delta = 1 . 2$ for the LS-PGA attack hyperparameters. For the discretized models, we used 16 levels. All adversarially trained models were trained on a mix of clean and adversarial examples.
+
+Table 13: Comparison of adversarial robustness on CIFAR-100. All adversarially trained models were trained on a mix of clean and adversarial examples.   
+
+<table><tr><td rowspan="2">Target</td><td rowspan="2">Source</td><td rowspan="2">Clean</td><td rowspan="2">White-box PGD/LS-PGA</td><td colspan="2">Black-box</td></tr><tr><td>Vanilla, Clean-trained</td><td>Vanilla, PGD-trained</td></tr><tr><td>evaaa</td><td>Vanilla One-hot</td><td>74.32</td><td>0</td><td>0.4</td><td>9.40</td></tr><tr><td rowspan="3"></td><td>Thermometer</td><td>73.25</td><td>16.55</td><td>55.72</td><td>19.33</td></tr><tr><td></td><td>74.44</td><td>16.50</td><td>50.33</td><td>18.49</td></tr><tr><td>Vanilla</td><td>64.46</td><td>6.02</td><td>7.46</td><td>11.77</td></tr><tr><td rowspan="2">A</td><td>One-hot</td><td>66.54</td><td>25.11</td><td>63.09</td><td>42.46</td></tr><tr><td>Thermometer</td><td>68.44</td><td>28.14</td><td>63.21</td><td>41.97</td></tr></table>
+
+# F EXPERIMENTS ON SVHN
+
+We list the experimental results on SVHN in Table 14. All adversarially trained models were trained only on adversarial examples.
+
+<table><tr><td rowspan="2">Target</td><td rowspan="2">Source</td><td></td><td>White-box</td><td colspan="2">Black-box</td></tr><tr><td>Clean</td><td>PGD/LS-PGA</td><td>Vanilla, Clean-trained</td><td>Vanilla, PGD-trained</td></tr><tr><td>erea</td><td>Vanilla</td><td>97.90</td><td>6.99</td><td>73.94</td><td>42.04</td></tr><tr><td rowspan="3"></td><td>One-hot</td><td>97.59</td><td>56.02</td><td>75.77</td><td>41.59</td></tr><tr><td>Thermometer</td><td>97.87</td><td>56.37</td><td>78.04</td><td>41.69</td></tr><tr><td>Vanilla</td><td>94.79</td><td>59.63</td><td>81.24</td><td>46.77</td></tr><tr><td rowspan="2">A</td><td>One-hot</td><td>95.12</td><td>87.34</td><td>83.84</td><td>43.40</td></tr><tr><td>Thermometer</td><td>97.74</td><td>94.77</td><td>84.97</td><td>48.67</td></tr></table>
+
+Table 14: Comparison of adversarial robustness on SVHN.
+
+# G SUPPLEMENTARY FIGURES
+
+![](images/a8ebdd6c09562c3bff5cb9abe039c9d87ccd31689672f17c3dd1b5d3353ae4be.jpg)  
+In Figure 4 we plot the effect of increasing the levels of discretization for the MNIST and CIFAR-10 datasets.   
+Figure 4: The effect of increasing the number of distinct discretization levels on the accuracy of the model on MNIST and CIFAR-10. (4a) shows the accuracy on on MNIST for discretized models trained on a mix of legitimate and adversarial examples. (4b) shows the accuracy on CIFAR-10 for discretized models trained only on adversarial examples.
+
+In Figure 5 we plot the convergence rate of clean trained and adversarially trained models on the CIFAR-10 dataset. Note that thermometer encoded inputs converge much faster in accuracy on both clean and adversarial inputs.
+
+Figure 6 plots the norm of the gradient as a function of the number of iterations of the attack on MNIST. Note that the gradient vanishes at around 40 iterations, which coincides with the loss stabilizing in Figure 3.
+
+In Figure 7, we create a linear interpolation between a clean image and an adversarial example, and then continue to extrapolate along this line, evaluating probability of each class at each point. In models trained on unquantized inputs, the class probabilities are all mostly piecewise linear in both the positive and negative directions. In contrast, the discretized model has a much more jagged and irregular shape.
+
+In Figure 8, we plot the error for different models on various values of $\varepsilon$ . The discretized models are extremely robust to all values less-than-or-equal-to the values that they have been exposed to during training. However, beyond this threshold, discretized models collapse immediately, while real-valued models still maintain some semblance of robustness. This exposes a weakness of the discretization approach; the same nonlinearity that helps it learn to become robust to all attacks it sees during training-time causes its behavior is unpredictable beyond that.
+
+However, we believe that the fact that the performance of thermometer-encoded models degrades more quickly than that of vanilla models beyond the training epsilon is a significant weakness in practice, but no worse than other defenses. The “standard setting” for the adversarial example problem (in which we constrain the L-infinity norm of the perturbed image to an epsilon ball around the original image) was designed to ensure that any adversarially-perturbed image is still recognizable as its original image by a human. However, this artificial constraint excludes many other potential attacks that also result in human-recognizable images. State-of-the art defenses in the standard setting can still be easily defeated by non-standard attacks; for an example of this, see appendix A of ICLR submission “Adversarial Spheres”. A “larger epsilon” attack is just one special case of a “non-standard” attack. If we permit non-standard attacks, a fair comparison would show that all current approaches are easily breakable. There is nothing special about the “larger epsilon” attack that makes a vulnerability to this non-standard attack in particular more problematic than vulnerabilities to other non-standard attacks.
+
+![](images/f54afb62fd3df9546cc33fc79e2f193ef3b221d2ab127c90e7d8126cc8b84224.jpg)  
+Figure 5: Comparison of the convergence rate of various adversarially trained models on the CIFAR-10 dataset. The discretized models use 16 levels per color channel. (5a) shows the accuracy on clean examples, while (5b) shows the accuracy on white-box PGD/LS-PGA examples, in wall-clock time.
+
+![](images/26d31999144179f1b87e876690579d277bda1d16fe9adca44b3657d0a5e4dc09.jpg)  
+Figure 6: Gradient norm for iterated white-box attacks on various models on a randomly chosen data point from MNIST. (6a) shows the gradient norm on discretized models as a function of steps of LS-PGA, while (6b) shows the gradient norm on a vanilla model as a function of steps of PGD.
+
+In Figures 9, 10 , 11, 12 , 13 and 14 we plot several examples of church-window plots for MNIST (Goodfellow et al., 2014). Each plot is crafted by taking several test-set images, calculating the vector corresponding to an adversarial attack on each image, and then choosing an additional random orthogonal direction. In each plot, the clean image is at the center and corresponds to the color white, the $x$ -axis corresponds to the magnitude of a perturbation in the adversarial direction, and the $y$ -axis corresponds to the magnitude of a perturbation in the orthogonal direction. Note that we use the same random seed to generate the test set examples and the adversarial directions across different church-window plots.
+
+![](images/0604ba8d594b2cc20ab2cd825ddd95d7f109060c47f4da6bd6c0c716b6cb48a4.jpg)  
+Figure 7: Linear extrapolation plot as in Goodfellow et al. (2014) for MNIST. (7a) shows the behavior of a vanilla model while (7b) for a discretized model using 16 levels and thermometer encoding. The $\varepsilon$ -bound is $[ - 1 . 5 , 1 . 5 ]$ .
+
+![](images/c78f8a5fe014e2f444bb58892bc5fb5cb13c6cf56a7ada4884d05a07ae541f0a.jpg)  
+Figure 8: Plot showing the accuracy of various adversarially trained models on MNIST with $\varepsilon =$ 0.3 (8a) and on CIFAR-10 with $\varepsilon = 0 . 0 3 1$ (8b), when attacked with increasing values of $\varepsilon$ using PGD/LS-PGA.
+
+![](images/d1f6655e799c3df8ee0c7d91633ddd42647398284e1ce47bb635c2f380feca43.jpg)  
+Figure 9: Church-window plots of clean-trained models on MNIST. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on nondiscretized models.
+
+![](images/a7c9b35d39f9aae5b0e758c5718f5e087620a70b03f03c951a8a59a7f1b044b2.jpg)  
+Figure 10: Church-window plots of adversarially-trained models on MNIST, trained on only adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ .
+
+![](images/f110fa7dc03c228647aad430e7c23c0aa9d8f9045ebe745e79b586287148d078.jpg)  
+Figure 11: Church-window plots of adversarially-trained models on MNIST, trained using a mix of clean and adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on non-discretized models.
+
+![](images/de62ebb60756bab3e9b9f0d3e2a7a522816c61a5478d63537904a6753e8ba708.jpg)  
+Figure 12: Church-window plots of clean-trained models on CIFAR-10. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on nondiscretized models.
+
+![](images/533fb3c9d3296390750f7f7c0d5de121e121313c39a27778531efd51f4a48fb9.jpg)  
+Figure 13: Church-window plots of adversarially-trained models on CIFAR-10, trained on only adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y \cdot$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ .
+
+![](images/a379953bd90bdb3939721bdba8051da89b967e596d108733d52c8302e4f8dc62.jpg)  
+Figure 14: Church-window plots of adversarially-trained models on CIFAR-10, trained using a mix of clean and adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on non-discretized models.

parse/train/S18Su--CW/S18Su--CW_content_list.json

@@ -0,0 +1,1829 @@
+[
+    {
+        "type": "text",
+        "text": "THERMOMETER ENCODING: ONE HOT WAY TO RESIST ADVERSARIAL EXAMPLES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            820,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Jacob Buckman∗ †, Aurko Roy∗, Colin Raffel, Ian Goodfellow   \nGoogle Brain   \nMountain View, CA   \n{buckman, aurkor, craffel, goodfellow}@google.com ",
+        "bbox": [
+            184,
+            170,
+            661,
+            227
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            262,
+            544,
+            277
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "It is well known that it is possible to construct “adversarial examples” for neural networks: inputs which are misclassified by the network yet indistinguishable from true data. We propose a simple modification to standard neural network architectures, thermometer encoding, which significantly increases the robustness of the network to adversarial examples. We demonstrate this robustness with experiments on the MNIST, CIFAR-10, CIFAR-100, and SVHN datasets, and show that models with thermometer-encoded inputs consistently have higher accuracy on adversarial examples, without decreasing generalization. State-of-the-art accuracy under the strongest known white-box attack was increased from $9 3 . 2 0 \\%$ to $9 4 . 3 0 \\%$ on MNIST and $5 0 . 0 0 \\%$ to $7 9 . 1 6 \\%$ on CIFAR-10. We explore the properties of these networks, providing evidence that thermometer encodings help neural networks to find more-non-linear decision boundaries. ",
+        "bbox": [
+            233,
+            295,
+            764,
+            460
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION AND RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            488,
+            521,
+            503
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adversarial examples are inputs to machine learning models that are intentionally designed to cause the model to produce an incorrect output. The term was introduced by Szegedy et al. (2014) in the context of neural networks for computer vision. In the context of spam and malware detection, such inputs have been studied earlier under the name evasion attacks (Biggio et al., 2013). Adversarial examples are interesting from a scientific perspective, because they demonstrate that even machine learning models that have superhuman performance on I.I.D. test sets fail catastrophically on inputs that are modified even slightly by an adversary. Adversarial examples also raise concerns in the emerging field of machine learning security because malicious attackers could use adversarial examples to cause undesired behavior (Papernot et al., 2016). ",
+        "bbox": [
+            173,
+            520,
+            825,
+            643
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Unfortunately, there is not yet any known strong defense against adversarial examples. Adversarial examples that fool one model often fool another model, even if the two models are trained on different training examples (corresponding to the same task) or have different architectures (Szegedy et al., 2014), so an attacker can fool a model without access to it. Attackers can improve their success rate by sending inputs to a model, observing its output, and fitting their own own copy of the model to the observed input-output pairs (Papernot et al., 2016). Attackers can also improve their success rate by searching for adversarial examples that fool multiple different models—such adversarial examples are then much more likely to fool the unknown target model (Liu et al., 2016). Szegedy et al. (2014) proposed to defend the model using adversarial training (training on adversarial examples as well as regular examples) but it was not feasible to generate enough adversarial examples in the inner loop of the training process for the method to be effective at the time. Szegedy et al. (2014) used a large number of iterations of L-BFGS to produce their adversarial examples. Goodfellow et al. (2014) developed the fast gradient sign method (FGSM) of generating adversarial examples and demonstrated that adversarial training is effective for reducing the error rate on adversarial examples. A major difficulty of adversarial training is that it tends to overfit to the method of adversarial example generation used at training time. For example, models trained to resist FGSM adversarial examples usually fail to resist L-BFGS adversarial examples. Kurakin et al. (2016) introduced the basic iterative method (BIM) which lies between FGSM and L-BFGS on a curve trading speed for effectiveness (the BIM consists of running FGSM for a medium number of iterations). Adversarial training using BIM still overfits to the BIM, unfortunately, and different iterative methods can still successfully attack the model. Recently, Madry et al. (2017) showed that adversarial training using adversarial examples created by adding random noise before running BIM results in a model that is highly robust against all known attacks on the MNIST dataset. However, it is less effective on more complex datasets, such as CIFAR. A strategy for training networks which are robust to adversarial attacks across all contexts is still unknown. In this work, we demonstrate that thermometer code discretization and one-hot code discretization of real-valued inputs to a model significantly improves its robustness to adversarial attack, advancing the state of the art in this field. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            887
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 INPUT DISCRETIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            262,
+            405,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We propose to break the linear extrapolation behavior of machine learning models by preprocessing the input with an extremely nonlinear function. This function must still permit the machine learning model to function successfully on naturally occurring inputs. The recent success of the PixelRNN model (Oord et al., 2016) has demonstrated that one-hot discrete codes for 256 possible values of color pixels are effective representations for input data. Other extremely nonlinear functions may also defend against adversarial examples, but we focused attention on vector-valued discrete encoding as our nonlinear function because of the evidence from PixelRNN that it would support successful machine learning. ",
+        "bbox": [
+            174,
+            292,
+            825,
+            405
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Images are often encoded as a 3D tensor of integers in the range [0, 255]. The tensor’s three dimensions correspond to the image’s height, width, and color channels (e.g. three for RGB, one for greyscale). Each value represents an intensity value for a given color at a given horizontal/vertical position. For classification tasks, these values are typically normalized to floating-point approximations in the range (0, 1). Input discretization refers to the process of separating these continuousvalued pixel inputs into a set of non-overlapping buckets, which are each mapped to a fixed binary vector. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            508
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Past work, for example depth-color-squeezing (Xu et al., 2017), has explored what we will refer to as quantization of inputs as a potential defense against adversarial examples. In that approach, each pixel value is mapped to the low-bit version of its original value, which is a fixed scalar. The key novel aspect of our approach is that rather than replacing a real number with a number of low bit depth, we replace each real number with a binary vector. Different values of the real number activate different bits of the input vector. Multiplying the input vector by the network’s weights thus performs an operation similar to an embedding lookup in a language model, so different input values actually use different parameters of the network. To avoid confusion, we will consistently refer to scalar-toscalar precision reduction as quantization and scalar-to-vector encoding schemes as discretization throughout this work. A comparison of these techniques can be seen in Table 1. Note that, unlike depth-color-squeezing, discretization makes a meaningful change to the model, even when it is configured to use enough discretization levels to avoid losing any information from a traditionally formatted computer vision training set; discretizing each pixel to 256 levels will preserve all of the information contained in the original image. Discretization defends against adversarial examples by changing which parameters of the model are used, and may also discard information if the number of discretization levels is low; quantization can only defend the model by discarding information. ",
+        "bbox": [
+            174,
+            515,
+            825,
+            738
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "table",
+        "img_path": "images/2b2debaaa5e0250083ec71b0d962a430a1c5cdf6fa43b6551dc713a1b11f0c5b.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Real-valued</td><td>Quantized</td><td>Discretized (one-hot)</td><td>Discretized (thermometer)</td></tr><tr><td>0.13</td><td>0.15</td><td>[0100000000]</td><td>[0111111111]</td></tr><tr><td>0.66</td><td>0.65</td><td>[0000001000]</td><td>[0000001111]</td></tr><tr><td>0.92</td><td>0.95</td><td>[0000000001]</td><td>[0000000001]</td></tr></table>",
+        "bbox": [
+            230,
+            748,
+            764,
+            808
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Table 1: Examples mapping from continuous-valued inputs to quantized inputs, one-hot codes, and thermometer codes, with ten evenly-spaced levels. ",
+        "bbox": [
+            171,
+            818,
+            825,
+            845
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 DISCRETIZATION AS A DEFENSE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            437,
+            883
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In Goodfellow et al. (2014), the authors provide evidence that several network architectures, including LSTMs (Hochreiter & Schmidhuber, 1997), sigmoid networks (Han & Moraga, 1995), and maxout networks (Goodfellow et al., 2013), are vulnerable to adversarial examples due to the empirical fact that, when trained, the loss function of these networks tends to be highly linear with respect to its inputs. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We briefly recall the reasoning of Goodfellow et al. (2014). Assume that we have a logistic regressor with weight matrix $w$ . Consider an image $x \\in \\mathbb { R } ^ { n }$ which is perturbed into $\\widetilde { x } = x + \\eta$ by some noise $\\eta$ such that $\\| \\eta \\| _ { \\infty } \\le \\varepsilon$ for some $\\varepsilon$ . The probability that the model assigns to the true class is equal to: ",
+        "bbox": [
+            174,
+            151,
+            825,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/19342409ab6abf187cc42b5a103711c42ce0001751866826710f083b65402c8c.jpg",
+        "text": "$$\n\\mathbb { L } ( \\widetilde { \\boldsymbol { x } } ) = \\sigma ( \\boldsymbol { w } ^ { \\top } \\widetilde { \\boldsymbol { x } } ) = \\sigma ( \\boldsymbol { w } ^ { \\top } ( \\boldsymbol { x } + \\boldsymbol { \\eta } ) ) = \\sigma ( \\boldsymbol { w } ^ { \\top } \\boldsymbol { x } + \\boldsymbol { w } ^ { \\top } \\boldsymbol { \\eta } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            318,
+            218,
+            678,
+            237
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "If the perturbation $\\eta$ is adversarial, such as in the case where $\\begin{array} { r } { \\eta _ { i } : = \\varepsilon \\cdot \\mathrm { s i g n } \\left( \\frac { \\partial \\mathbb { L } ( x ) } { \\partial x _ { i } } \\right) } \\end{array}$ , then the input to the sigmoid is increased by $\\varepsilon \\cdot n$ . If $n$ is large, as is typically the case in images and other highdimensional spaces of interest, this linearity implies that even imperceptibly small values of $\\varepsilon$ can have a large effect on the model’s prediction, making the model vulnerable to adversarial attacks. ",
+        "bbox": [
+            173,
+            248,
+            825,
+            314
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Though neural networks in principle have the capacity to represent highly nonlinear functions, networks trained via stochastic gradient descent on real-world datasets tend to converge to mostly-linear solutions. This is illustrated in the empirical studies conducted by Goodfellow et al. (2014). One hypothesis proposed to explain this phenomenon is that the nonlinearities typically used in networks are either piecewise linear, like ReLUs, or approximately linear in the parts of their domain in which training takes place, like the sigmoid function. ",
+        "bbox": [
+            173,
+            320,
+            825,
+            405
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One potential solution to this problem is to use more non-linear activation functions, such as quadratic or RBF units. Indeed, it was shown by Goodfellow et al. (2014) that such units were more resistant to adversarial perturbations of their inputs. However, these units are difficult to train, and the resulting models do not generalize very well (Goodfellow et al., 2014), sacrificing accuracy on clean examples. As an alternative to introducing highly non-linear activation functions in the network, we propose applying a non-differentiable and non-linear transformation (discretization) to the input, before passing it into the model. A comparison of the input to the model under various regimes can be seen in Figure 1, highlighting the strong non-linearity of discretization techniques. ",
+        "bbox": [
+            173,
+            411,
+            825,
+            523
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/1babc487bea1da3867ddd67e758440fd4bfd2a7dd066a336fbbff60b9365e8fd.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of regular inputs, quantized inputs, and discretized inputs (16 levels, projected to one dimension) on MNIST, adversarially trained with $\\varepsilon = 0 . 3$ . The $x$ -axis represents the true pixel value of the image, and the $y$ -axis represents the value that is passed as input to the network after the input transformation has been applied. For real-valued inputs, the inputs to the network are affected linearly by perturbations to the input. Quantized inputs are also affected approximately linearly by perturbations where $\\varepsilon$ is greater than the bucket width. Discretizing the input, and then using learned weights to project the discretized value back to a single scalar, we see that the model has learned a highly non-linear function to represent the input in a fashion that is effective for resisting the adversarial perturbations it has seen. When starting at the most common pixel-values for MNIST, 0 and 1, any perturbation of the pixels (where $\\varepsilon \\le 0 . 3 )$ ) has barely any effect on the input to the network. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            553,
+            803,
+            736
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.2 TYPES OF DISCRETIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            405,
+            117
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this work we consider two approaches to constructing discretized representations $f ( x )$ of the input image $x$ . Assume for the sake of simplicity that the entries of $x$ take values in the continuous domain $[ 0 , 1 ]$ . ",
+        "bbox": [
+            173,
+            128,
+            825,
+            172
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first describe a quantization function $b$ . Choose $0 < b _ { 1 } < b _ { 2 } < \\cdot \\cdot \\cdot < b _ { k } = 1$ in some fashion. (In this work, we simply divide the domain evenly, i.e. $\\begin{array} { r } { b _ { i } = \\frac { i } { k } } \\end{array}$ .) For a real number $\\theta \\in [ 0 , 1 ]$ define $b ( \\theta )$ to be the largest index $\\alpha \\in \\{ 1 , \\ldots , k \\}$ such that $\\theta \\leq b _ { \\alpha }$ . ",
+        "bbox": [
+            173,
+            178,
+            825,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.1 ONE-HOT ENCODINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            236,
+            383,
+            251
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For an index $j \\in \\{ 1 , \\ldots , k \\}$ let $\\chi ( j ) \\in \\mathbb { R } ^ { k }$ be the indicator or one-hot vector of $j$ , i.e., ",
+        "bbox": [
+            173,
+            258,
+            736,
+            276
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a0a8cf10e5403f6feb84714620930bbba19a668a7285e5844c11900acb928f21.jpg",
+        "text": "$$\n\\chi ( j ) _ { l } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } l = j } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            282,
+            573,
+            318
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The discretization function is defined pixel-wise for a pixel $i \\in \\{ 1 , \\ldots , n \\}$ as: ",
+        "bbox": [
+            173,
+            324,
+            684,
+            340
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7120442f434cd3b5836c11f3e981c529cbd07b32d00dd116bb2a9628a200dda8.jpg",
+        "text": "$$\nf _ { o n e h o t } ( x _ { i } ) = \\chi \\left( b ( x _ { i } ) \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            344,
+            583,
+            363
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "One-hot encodings are simple to compute and understand, and are often used when it is necessary to represent a categorical variable in a neural network. However, one-hot encodings are not well suited for representing categorical variables with an interpretation of ordering between them. Note that the ordering information between two pixels $x _ { i }$ and $x _ { j }$ is lost by applying the transformation $f _ { o n e h o t }$ ; for a pair of pixels $i , j$ whenever $b ( x _ { i } ) \\neq b ( x _ { j } ) )$ , we see: ",
+        "bbox": [
+            173,
+            368,
+            826,
+            439
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b44c88d53fc42b7fe725319b69f778e994a772bb9ede8abd6ada74c76c621fef.jpg",
+        "text": "$$\n\\| \\chi ( b ( x _ { i } ) ) \\| _ { 2 } = \\| \\chi ( b ( x _ { j } ) ) \\| _ { 2 } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            444,
+            611,
+            463
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In the case of pixel values, this is not a good inductive bias, as there is a clear reason to believe that neighboring buckets are more similar to each other than distant buckets. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2.2 THERMOMETER ENCODINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            511,
+            426,
+            526
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to discretize the input image $x$ without losing the relative distance information, we propose thermometer encodings. For an index $j \\in \\{ 1 , \\ldots , k \\}$ , let $\\tau ( j ) \\in \\mathbb { R } ^ { k }$ be the thermometer vector defined as ",
+        "bbox": [
+            173,
+            535,
+            825,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/84aa81f1e2b0a9aabe126223a313095cfaaa857827c1581e4a23f74747c83572.jpg",
+        "text": "$$\n\\tau ( j ) _ { l } = { \\left\\{ \\begin{array} { l l } { 1 } & { { \\mathrm { i f ~ } } l \\geq j } \\\\ { 0 } & { { \\mathrm { o t h e r w i s e . } } } \\end{array} \\right. }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            583,
+            571,
+            618
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Then the discretization function $f$ is defined pixel-wise for a pixel $i \\in \\{ 1 , \\ldots , n \\}$ as: ",
+        "bbox": [
+            174,
+            625,
+            730,
+            640
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc78168d2a37525517d4fec8638194baa05ef1e5d63b516ddd50bf990dd17bcd.jpg",
+        "text": "$$\nf _ { t h e r m } ( x ) _ { i } = \\tau \\left( b ( x _ { i } ) \\right) = \\mathbb { C } ( f _ { o n e h o t } ( x _ { i } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            646,
+            638,
+            664
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { C }$ is the cumulative sum function, $\\mathbb { C } ( c ) _ { l } = \\sum _ { j = 0 } ^ { l } c _ { l }$ ",
+        "bbox": [
+            173,
+            671,
+            544,
+            705
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that the thermometer encoding preserves pairwise ordering information, i.e., for pixels $i , j$ if $b ( x _ { j } ) \\neq b ( x _ { k } )$ and $x _ { i } < x _ { j }$ then ",
+        "bbox": [
+            173,
+            712,
+            823,
+            741
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9b130f8646c68cc95bbceb99dc07dc16a382866069d43f165f94fead1751a38c.jpg",
+        "text": "$$\n\\left\\| \\tau ( b ( x _ { i } ) ) \\right\\| _ { 2 } < \\left\\| \\tau ( b ( x _ { j } ) ) \\right\\| _ { 2 } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            401,
+            746,
+            596,
+            765
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 WHITE-BOX ATTACKS ON DISCRETIZED INPUTS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            779,
+            540,
+            794
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Discretizing the input makes it difficult to attack the model with standard white-box attack algorithms, such as FGSM (Goodfellow et al., 2014) and PGD (Madry et al., 2017), since it is impossible to backpropagate through our discretization function to determine how to adversarially modify the model’s input. In this section, we describe two novel iterative attacks which allow us to construct adversarial examples for networks trained on discretized inputs. ",
+        "bbox": [
+            173,
+            804,
+            825,
+            876
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Constructing white-box attacks on discretized inputs serves two primary purposes. First, it allows us to more completely evaluate whether the model is robust to all adversarial attacks, as white-box attacks are typically more powerful than their black-box counterparts. Secondly, adversarial training is typically performed in a white-box fashion, and so in order to utilize and properly compare against the adversarial training techniques of Madry et al. (2017), it is important to have strong white-box attacks. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For ease of presentation, we will describe the attacks assuming that $f : \\mathbb { R } \\to \\mathbb { R } ^ { k }$ discretizes inputs into thermometer encodings; in order to attack one-hot encodings, simply replace all instances of $f _ { t h e r m }$ with $f _ { o n e h o t }$ , $\\tau$ with $\\chi$ , and $\\mathbb { C }$ with the identity function I. We represent the adversarial image after $t$ steps of the attack as $z ^ { t }$ , where the value of the ith pixel is $z _ { i } ^ { t }$ . ",
+        "bbox": [
+            174,
+            151,
+            825,
+            209
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The first attack, Discrete Gradient Ascent (DGA), follows the direction of the gradient of the loss with respect to $f ( x )$ , but is constrained at every step to be a discretized vector. If we have discretized the input image into $k$ -dimensional vectors using the one-hot encoding, this corresponds to moving to a vertex of the simplex $\\left( \\Delta _ { k } \\right) ^ { n }$ at every step. The second attack, Logit-Space Projected Gradient Ascent (LS-PGA), relaxes this assumption, allowing intermediate iterates to be in the interior of the simplex. The final adversarial image is obtained by projecting the final point back to the nearest vertex of the simplex. ",
+        "bbox": [
+            174,
+            214,
+            825,
+            314
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Note that if the number of attack steps is 1, then the two attacks are equivalent; however, for larger numbers of attack steps, LS-PGA is a generalization of DGA. ",
+        "bbox": [
+            176,
+            319,
+            821,
+            349
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3.1 DISCRETE GRADIENT ASCENT (DGA) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            366,
+            495,
+            380
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Following PGD (Madry et al., 2017), we initialize DGA by placing each pixel into a random bucket that is within $\\varepsilon$ of the pixel’s true value. At each step of the attack, we look at all buckets that are within $\\varepsilon$ of the true value, and select the bucket that is likely to do the most ‘harm’, as estimated by the gradient of setting that bucket’s indicator variable to 1, with respect to the model’s loss at the previous step. ",
+        "bbox": [
+            174,
+            390,
+            823,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0a8a21f923068660d20d6e41ce5c5f4ac9a273637073b0fe64cbfa4a794de862.jpg",
+        "text": "$$\n\\begin{array} { r l } & { z _ { i } ^ { 0 } = f _ { t h e r m } ( x _ { i } + U ( - \\varepsilon , \\varepsilon ) ) } \\\\ & { \\mathrm { h a r m } ( z _ { i } ^ { t } ) _ { l } = \\left\\{ \\begin{array} { l l } { ( z _ { i } ^ { t } - \\tau ( l ) ) ^ { \\top } \\cdot \\frac { \\partial \\mathbb { L } ( z ^ { t } ) } { \\partial z _ { i } ^ { t } } } & { \\mathrm { i f } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { 0 } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\\\ & { \\qquad z _ { i } ^ { t + 1 } = \\tau \\left( \\mathrm { a r g } \\operatorname* { m a x } \\left( \\mathrm { h a r m } \\left( z _ { i } ^ { t } \\right) \\right) \\right) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            236,
+            467,
+            758,
+            554
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Because the outcome of this optimization procedure will vary depending on the initial random perturbation, we suggest strengthening the attack by re-running it several times and using the perturbation with the greatest loss. The pseudo-code for the DGA attack is given in Section $\\mathbf { B }$ of the appendix. ",
+        "bbox": [
+            176,
+            558,
+            820,
+            614
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3.2 LOGIT-SPACE PROJECTED GRADIENT ASCENT (LS-PGA) ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            629,
+            647
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To perform LS-PGA, we soften the discrete encodings into continuous relaxations, and then perform standard Projected Gradient Ascent (PGA) on these relaxed values. We represent the distribution over embeddings as a softmax over logits $u$ , each corresponding to the unnormalized log-weight of a specific bucket’s embedding. To improve the attack, we scale the logits with temperature $T$ , allowing us to trade off between how closely our softmax approximates a true one-hot distribution as in the Gumbel-softmax trick (Jang et al., 2016; Maddison et al., 2016), and how much gradient signal the logits receive. At each step of a multi-step attack, we anneal this value via exponential decay with rate $\\delta$ . ",
+        "bbox": [
+            173,
+            656,
+            825,
+            768
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8917ac99edcaeb487851b70ae3d860f7005fc8a09d79157fe4763000b60e0529.jpg",
+        "text": "$$\n\\begin{array} { c } { { z _ { i } ^ { t } = \\mathbb C \\left( \\sigma \\left( \\frac { u _ { i } ^ { t } } { T ^ { t } } \\right) \\right) } } \\\\ { { z _ { i } ^ { f i n a l } = \\tau \\left( \\arg \\operatorname* { m a x } \\left( u _ { i } ^ { f i n a l } \\right) \\right) } } \\\\ { { T ^ { t } = T ^ { t - 1 } \\cdot \\delta } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            390,
+            777,
+            607,
+            859
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We initialize each of the logits randomly with values sampled from a standard normal distribution. At each step, we ensure that the model does not assign any probability to buckets which are not within $\\varepsilon$ of the true value by fixing the logits to be $- \\infty$ . The model’s loss is a continuous function of the logits, so we can simply utilize attacks designed for continuous-valued inputs, in this case PGA ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "with step-size $\\xi$ . ",
+        "bbox": [
+            174,
+            103,
+            282,
+            118
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4a8fd676fc209c58ef9dabe4a2d06491fa344a4cc4e2548805ffffbec81b3b7a.jpg",
+        "text": "$$\n\\begin{array} { r l } & { u _ { i } ^ { 0 } = \\left\\{ \\begin{array} { l l } { N \\left( \\mathbf { 0 } ; \\mathbf { 1 } \\right) } & { \\mathrm { i f ~ } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\\\ & { \\left( u _ { i } ^ { t + 1 } \\right) _ { l } = \\left\\{ \\begin{array} { l l } { \\left( u _ { i } ^ { t } \\right) _ { l } + \\xi \\cdot \\mathrm { s i g n } \\left( \\frac { \\partial \\mathbb { L } \\left( z ^ { t } \\right) } { \\partial u _ { i } ^ { t } } \\right) _ { l } } & { \\mathrm { i f ~ } \\exists ( - \\varepsilon \\leq \\eta \\leq \\varepsilon ) \\quad \\mathrm { s . t . } \\quad b ( x _ { i } + \\eta ) = l } \\\\ { - \\infty } & { \\mathrm { o t h e r w i s e . } } \\end{array} \\right. } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            127,
+            766,
+            209
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Because the outcome of this optimization procedure will vary depending on the initial perturbation, we suggest strengthening the attack by re-running it several times and using the perturbation with the greatest loss. The pseudo-code for the LS-PGA attack is given in Section B of the appendix. ",
+        "bbox": [
+            176,
+            234,
+            823,
+            277
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            300,
+            326,
+            315
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We compare models trained with input discretization to state-of-the-art adversarial defenses on a variety of datasets. We match the experimental setup of the prior literature as closely as possible. Rows labeled with “Vanilla (Madry)” give the numbers reported in Madry et al. (2017); other rows contain results of our own experiments, with “Vanilla” containing a direct replication. For our MNIST experiments, we use a convolutional network; for CIFAR-10, CIFAR-100, and SVHN we use a Wide ResNet (Zagoruyko & Komodakis, 2016). We use a network of depth 30 for the CIFAR10 and CIFAR-100 datasets, while for SVHN we use a network of depth 15. The width factor of all the Wide ResNets is set to $k = 4$ . 1 Unless otherwise specified, all quantized and discretized models use 16 levels. ",
+        "bbox": [
+            174,
+            332,
+            825,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We found that in all cases, LS-PGA was strictly more powerful than DGA, so all attacks on discretized models use LS-PGA with $\\xi = 0 . 0 1 , \\delta = 1 . 2$ , and 1 random restart. To be consistent with Madry et al. (2017), we describe attacks in terms of the maximum $\\ell _ { \\infty }$ -norm of the attack, $\\varepsilon$ . All MNIST experiments used $\\varepsilon = 0 . 3$ and 40 steps for iterative attacks; experiments on CIFAR used $\\varepsilon = 0 . 0 3 1$ and 7 steps for iterative attacks; experiments on SVHN used $\\varepsilon = 0 . 0 4 7$ and 10 steps for iterative attacks. These settings were used for adversarial training, white-box attacks, and blackbox attacks. Figure 3 plots the effectiveness of the iterated PGD/LS-PGA attacks on vanilla and discretized models for MNIST and shows that increasing the number of iterations beyond 40 would have no effect on the performance of the model on $\\ell _ { \\infty }$ -bounded adversarial examples for MNIST. ",
+        "bbox": [
+            173,
+            464,
+            825,
+            590
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Madry et al. (2017), adversarially-trained models are trained using exclusively adversarial inputs. This led to a small but noticeable loss in accuracy on clean examples, dropping from $9 9 . 2 \\%$ to $9 8 . 8 \\%$ on MNIST and from $9 5 . 2 \\%$ to $8 7 . 3 \\%$ on CIFAR-10 in return for more robustness towards adversarial examples. Past work has also sometimes performed adversarial training on batches composed of half clean examples and half adversarial examples (Goodfellow et al., 2014; Cisse et al., 2017). To be consistent with Madry et al. (2017), we list experiments on models trained only on adversarial inputs in the main paper; additional experiments on a mix of clean and adversarial inputs can be found in the appendix. ",
+        "bbox": [
+            174,
+            597,
+            825,
+            708
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We also run experiments exploring the model’s relationship with the number of distinct levels to which we quantize the input before discretizing it, and exploring various settings of hyperparameters for LS-PGA. ",
+        "bbox": [
+            174,
+            714,
+            823,
+            757
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            780,
+            281,
+            795
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Our adversarially-trained baseline models were able to approximately replicate the results of Madry et al. (2017). On all datasets, discretizing the inputs of the network dramatically improves resistance to adversarial examples, while barely sacrificing any accuracy on clean examples. Quantized models also beat the baseline, but with lower accuracy on clean examples. Discretization via thermometer encodings outperformed one-hot encodings in most settings. See Tables 2,3,4 and 5 for results on MNIST and CIFAR-10. Additional results on CIFAR-100 and SVHN are included in the appendix. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            896
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figures 2 and 5 (located in appendix), we plot the test-set accuracy across training timesteps for various adversarially trained models on the SVHN and CIFAR-10 datasets, and observe that the discretized models become robust against adversarial examples more quickly. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/cb8cb5a8b640a5bea75041a868f04f94e323b622d4b2dc7e358fd11b80638f03.jpg",
+        "table_caption": [
+            "Table 2: Comparison of adversarial robustness to white-box attacks on MNIST . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>PGD/LS-PGA</td></tr><tr><td rowspan=2 colspan=1>ereaa</td><td rowspan=2 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=2 colspan=1>99.2099.3099.1999.1399.20</td><td rowspan=1 colspan=1>6.40</td><td rowspan=2 colspan=1>-0000</td></tr><tr><td rowspan=1 colspan=1>0.191.1000</td></tr><tr><td rowspan=3 colspan=1>Y1nit apt</td><td rowspan=3 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=3 colspan=1>98.8098.6798.7598.6199.03</td><td rowspan=1 colspan=1>95.6096.1796.29</td><td rowspan=3 colspan=1>93.2093.3094.2394.3094.02</td></tr><tr><td rowspan=1 colspan=1>96.22</td></tr><tr><td rowspan=1 colspan=1>95.84</td></tr></table>",
+        "bbox": [
+            295,
+            157,
+            700,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/cf2125c8de0866bf3201652f2cdb15f7a09d33b83a3bd403b6a14005255dcd8b.jpg",
+        "table_caption": [
+            "Table 3: Comparison of adversarial robustness to black-box attacks on MNIST . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\" rowspan=\"2\">Source Target</td><td rowspan=\"2\"></td><td colspan=\"3\">Clean</td><td colspan=\"3\">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td rowspan=\"3\">Ereaa</td><td rowspan=\"3\">Vanilla Quantized One-hot</td><td>2.04</td><td>36.02</td><td>24.58</td><td>3.48</td><td>80.44</td><td>57.69</td></tr><tr><td>39.22</td><td>32.39</td><td>25.63</td><td>75.02</td><td>75.92</td><td>52.32</td></tr><tr><td>14.57</td><td>6.91</td><td>8.11</td><td>39.02</td><td>39.60</td><td>18.02</td></tr><tr><td rowspan=\"6\">11p1l Apv</td><td rowspan=\"6\">Thermometer Vanilla (Madry)</td><td>41.12</td><td>14.30</td><td>10.98</td><td>61.84</td><td>59.16</td><td>32.93</td></tr><tr><td>=</td><td></td><td>1</td><td>96.0</td><td>=</td><td>1</td></tr><tr><td>Quantized</td><td>97.65</td><td>98.16</td><td>97.14</td><td>95.27 95.31</td><td>96.53</td></tr><tr><td>Vanilla One-hot</td><td>97.62</td><td>98.05</td><td>97.06 95.43</td><td>95.38</td><td>96.23</td></tr><tr><td>97.78</td><td>98.48</td><td>97.87</td><td>96.87</td><td>96.60</td><td>96.87</td></tr><tr><td>Thermometer 98.07</td><td>98.75</td><td>98.02</td><td>97.05</td><td>96.88</td><td>97.13</td></tr></table>",
+        "bbox": [
+            174,
+            364,
+            857,
+            527
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/0bb15de51702965b8a72d0eb8eb00226b0ad620898e95f8b30f37bb26550c3c2.jpg",
+        "table_caption": [
+            "Table 4: Comparison of adversarial robustness to white-box attacks on CIFAR-10 . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>FGSM</td><td rowspan=1 colspan=1>PGD/LS-PGA</td></tr><tr><td rowspan=2 colspan=1>eeeaa</td><td rowspan=2 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=2 colspan=1>95.2094.2993.4993.2694.22</td><td rowspan=1 colspan=1>25.10</td><td rowspan=2 colspan=1>4.101.663.5753.1150.50</td></tr><tr><td rowspan=1 colspan=1>46.1543.8952.0748.50</td></tr><tr><td rowspan=1 colspan=1>11p11 &#x27;Apv</td><td rowspan=1 colspan=1>Vanilla (Madry)VanillaQuantizedOne-hotThermometer</td><td rowspan=1 colspan=1>87.387.6785.7588.6789.88</td><td rowspan=1 colspan=1>60.359.753.5368.7680.96</td><td rowspan=1 colspan=1>50.041.7842.0967.8379.16</td></tr></table>",
+        "bbox": [
+            295,
+            571,
+            700,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            786,
+            312,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Goodfellow et al. (2014), the seeming linearity of deep neural networks was shown by visualizing the networks in several different ways. To test our hypothesis that discretization breaks some of this linearity, we replicate these visualizations and contrast them to visualizations of discretized models. See Appendix G for an illustration of these properties. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For non-discretized, clean trained models, test-set examples always yield a linear boundary between correct and incorrect classification; in contrast, non-adversarially-trained models have a more interesting parabolic shape (see Figure 9). ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/6a2369281a6b9b07fba7eeae0503af9c6467d64c0e47c8bd53930a9543661f21.jpg",
+        "table_caption": [
+            "Table 5: Comparison of adversarial robustness to black-box attacks on CIFAR-10 . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td colspan=\"2\" rowspan=\"2\">Source Target</td><td rowspan=\"2\"></td><td colspan=\"3\">Clean</td><td colspan=\"3\">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td rowspan=\"4\">evaa</td><td>Vanilla (Madry)</td><td>0.0</td><td>1</td><td>1</td><td>79.7</td><td>1</td><td>1</td></tr><tr><td>Vanilla</td><td>3.38</td><td>60.10</td><td>52.60</td><td>45.48</td><td>37.21</td><td>49.91</td></tr><tr><td>Quantized</td><td>70.54</td><td>62.46</td><td>55.38</td><td>51.74</td><td>45.37</td><td>55.64</td></tr><tr><td>One-hot</td><td>83.00</td><td>56.25</td><td>63.94</td><td>54.59</td><td>49.21</td><td>57.28</td></tr><tr><td rowspan=\"5\">11pl apa</td><td>Thermometer Vanilla (Madry)</td><td>80.33</td><td>66.22</td><td>53.45</td><td>57.04</td><td>51.03</td><td>60.90</td></tr><tr><td></td><td>85.60</td><td>1</td><td>1</td><td>67.0</td><td>1</td><td>1</td></tr><tr><td>Vanilla</td><td>85.60</td><td>74.99</td><td>73.78</td><td>67.0</td><td>50.09</td><td>71.03</td></tr><tr><td>Quantized</td><td>84.56</td><td>82.43</td><td>82.22</td><td>72.52</td><td>72.29</td><td>79.43</td></tr><tr><td>One-hot Thermometer</td><td>86.01 88.25</td><td>77.19 81.59</td><td>77.70 80.80</td><td>61.92 67.96</td><td>60.02 67.43</td><td>72.89 77.68</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            857,
+            277
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/2bf62500dea56cf3c5583933ce283039d15429aef2ff7e82327b7f820baa6c41.jpg",
+        "image_caption": [
+            "Figure 2: Comparison of the convergence rate of various adversarially trained models on the SVHN dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            338,
+            772,
+            500
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/7bd4936771b204f572b896b319647e0cafa645e72147b75f92d688d6fe438bbe.jpg",
+        "image_caption": [
+            "Figure 3: Loss for iterated white-box attacks on various models on a randomly chosen data point from MNIST. By step 40, which is where we evaluate, the loss of the point found by iterative attacks has converged. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            575,
+            766,
+            737
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When discretizing the input, we introduce $C _ { w } \\cdot C _ { h } \\cdot C _ { o } \\cdot c \\cdot ( k - 1 )$ extra parameters, where $c$ is the number of channels in the image, $k$ is the number of levels of discretization, and $C _ { w } , C _ { h } , C _ { o }$ are the width, height, and output channels of the first convolutional layer. Discretizing using 16 levels introduced $0 . 0 3 \\%$ extra parameters for MNIST, $0 . 0 8 \\%$ for CIFAR-10 and CIFAR-100, and $2 . 3 \\%$ for SVHN. This increase is negligible, so it is likely that the robustness comes from the input discretization, and is not merely a byproduct of having a slightly higher-capacity model. ",
+        "bbox": [
+            173,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            318,
+            118
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Our findings convincingly demonstrate that the use of thermometer encodings, in combination with adversarial training, can reduce the vulnerability of neural network models to adversarial attacks. Our analysis reveals that the resulting networks are significantly less linear with respect to their inputs, supporting the hypothesis of Goodfellow et al. (2014) that many adversarial examples are caused by over-generalization in networks that are too linear. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            203
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            223,
+            285,
+            238
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Battista Biggio, Igino Corona, Davide Maiorca, Blaine Nelson, Nedim Srndi ˇ c, Pavel Laskov, Gior- ´ gio Giacinto, and Fabio Roli. Evasion attacks against machine learning at test time. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 387– 402. Springer, 2013. ",
+        "bbox": [
+            173,
+            246,
+            826,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In International Conference on Machine Learning, pp. 854–863, 2017. ",
+        "bbox": [
+            174,
+            310,
+            823,
+            353
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron Courville, and Yoshua Bengio. Maxout networks. arXiv preprint arXiv:1302.4389, 2013. ",
+        "bbox": [
+            173,
+            361,
+            823,
+            390
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, Jonathon Shlens, and Christian Szegedy. Explaining and harnessing adversarial examples. arXiv preprint arXiv:1412.6572, 2014. ",
+        "bbox": [
+            173,
+            397,
+            823,
+            428
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jun Han and Claudio Moraga. The influence of the sigmoid function parameters on the speed of backpropagation learning. From Natural to Artificial Neural Computation, pp. 195–201, 1995. ",
+        "bbox": [
+            171,
+            434,
+            823,
+            464
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            470,
+            823,
+            515
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            522,
+            821,
+            551
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Yu Sun, Zhuang Liu, Daniel Sedra, and Kilian Q Weinberger. Deep networks with stochastic depth. In European Conference on Computer Vision, pp. 646–661. Springer, 2016. ",
+        "bbox": [
+            173,
+            559,
+            823,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eric Jang, Shixiang Gu, and Ben Poole. Categorical reparameterization with gumbel-softmax. arXiv preprint arXiv:1611.01144, 2016. ",
+        "bbox": [
+            173,
+            595,
+            823,
+            625
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alexey Kurakin, Ian Goodfellow, and Samy Bengio. Adversarial machine learning at scale. arXiv preprint arXiv:1611.01236, 2016. ",
+        "bbox": [
+            174,
+            632,
+            823,
+            661
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013. ",
+        "bbox": [
+            173,
+            669,
+            823,
+            699
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yanpei Liu, Xinyun Chen, Chang Liu, and Dawn Song. Delving into transferable adversarial examples and black-box attacks. CoRR, abs/1611.02770, 2016. URL http://arxiv.org/abs/ 1611.02770. ",
+        "bbox": [
+            176,
+            705,
+            823,
+            748
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chris J Maddison, Andriy Mnih, and Yee Whye Teh. The concrete distribution: A continuous relaxation of discrete random variables. arXiv preprint arXiv:1611.00712, 2016. ",
+        "bbox": [
+            174,
+            757,
+            820,
+            786
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            794,
+            821,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Aaron van den Oord, Nal Kalchbrenner, and Koray Kavukcuoglu. Pixel recurrent neural networks. arXiv preprint arXiv:1601.06759, 2016. ",
+        "bbox": [
+            173,
+            844,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Papernot, Patrick McDaniel, Ian Goodfellow, Somesh Jha, Z Berkay Celik, and Ananthram Swami. Practical black-box attacks against deep learning systems using adversarial examples. arXiv preprint arXiv:1602.02697, 2016. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. ICLR, abs/1312.6199, 2014. URL http://arxiv.org/abs/1312.6199. ",
+        "bbox": [
+            178,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Weilin Xu, David Evans, and Yanjun Qi. Feature squeezing: Detecting adversarial examples in deep neural networks. arXiv preprint arXiv:1704.01155, 2017. ",
+        "bbox": [
+            176,
+            156,
+            823,
+            185
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            224
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A HYPERPARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            253,
+            380,
+            270
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the hyperparameters used in our experiments. For CIFAR-10 and CIFAR-100 we follow the standard data augmenting scheme as in (Lin et al., 2013; He et al., 2016; Huang et al., 2016; Zagoruyko & Komodakis, 2016): each training image is zero-padded with 4 pixels on each side and randomly cropped to a new $3 2 \\times 3 2$ image. The resulting image is randomly flipped with probability 0.5, it’s brightness is adjusted with a delta chosen uniformly at random in the interval $[ - 6 3 , 6 3 )$ and it’s contrast is adjusted using a random contrast factor in the interval [0.2, 1.8]. For MNIST we use the Adam optimizer with a fixed learning rate of $1 \\mathrm { e } { - 4 }$ as in Madry et al. (2017). For CIFAR-10 and CIFAR-100 we use the Momentum optimizer with momentum 0.9, $\\ell _ { 2 }$ weight decay of $\\lambda = 0 . 0 0 0 5$ and an initial learning rate of 0.1 which is annealed by a factor of 0.2 after epochs 60, 120 and 160 respectively as in Zagoruyko & Komodakis (2016). For SVHN we use the same optimizer with initial learning rate of $\\mathrm { 1 e { - } 2 }$ which is annealed by a factor of 0.1 after epochs 80 and 120 respectively. We also use a dropout of 0.3 for CIFAR-10, CIFAR-100 and SVHN. ",
+        "bbox": [
+            173,
+            286,
+            825,
+            465
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B PSEUDO-CODE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            487,
+            333,
+            503
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The DGA attack is described in Algorithm 2 and the LS-PGA attack is described in Algorithm 3.   \nBoth these algorithms make use of a getM ask() sub-routine which is described in Algorithm 1. ",
+        "bbox": [
+            176,
+            520,
+            821,
+            549
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/9376c7f2852ce1eaf9c3b18c9853655bc772a48fc60e32f3a1bebfc9fa57523b.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Algorithm 1: Sub-routine for getting an $\\varepsilon$ -discretized mask of an image. "
+        ],
+        "table_body": "<table><tr><td></td><td>Input: Image x, parameter ε</td></tr><tr><td></td><td>Output: ε-discretized mask around x</td></tr><tr><td>2</td><td>mask ← (0)nxk</td></tr><tr><td>3</td><td>low ← max{0,x - ε}</td></tr><tr><td>4</td><td>high ← min{1,𝑥 +ε}</td></tr><tr><td>5</td><td>for α←O to1by do</td></tr><tr><td>6</td><td>mask ← mask+ fonehot (α * low + (1- α) * high) end</td></tr><tr><td>7</td><td>return mask</td></tr><tr><td></td><td></td></tr></table>",
+        "bbox": [
+            161,
+            568,
+            823,
+            705
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "C ADDITIONAL EXPERIMENTS ON MNIST ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            758,
+            544,
+            775
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this section we list the additional experiments we performed using discretized models on MNIST. The main hyperparameters of Algorithm 3 are the step size $\\xi$ used to perform the projected gradient ascent, and the annealing rate of $\\delta$ . We found that the choice of these hyperparameters was not critical to the robustness of the model. In particular, we performed experiments with $\\xi = 1 . 0$ and $\\xi = 0 . 0 0 1$ , and both achieved similar accuracies as in Table 2 and Table 3. Additionally, we found that without annealing, i.e., $\\delta = 1 . 0$ , the performance was only slightly worse than with $\\delta = 1 . 2$ . ",
+        "bbox": [
+            174,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We also experimented with discretizing by using percentile information per color channel instead of using uniformly distributed buckets. This did not result in any significant changes in robustness or accuracy for the MNIST dataset. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Input: Image $x$ , label $y$ , discretization function $f$ , loss $\\mathbb { L } ( \\pmb \\theta , f ( x ) , y )$ , l attack steps, parameter $\\varepsilon$ Output: Adversarial input to the network $z ^ { \\prime }$ 1 $\\eta  U ( - \\varepsilon , \\varepsilon )$ $ { \\vert z _ { 0 } \\gets f ( x + \\dot { \\eta } ) }$ 3 $\\mathrm { m a s k }  g e t M a s k ( x , \\varepsilon )$ for $t \\gets 1$ to $l$ do $/ \\star$ Loop invariant: $z _ { i } ^ { t }$ is discretized for every pixel i \\*/ 5 $\\mathrm { g r a d }  \\nabla _ { z ^ { t - 1 } } \\mathbb { L } ( \\pmb \\theta , z ^ { t - 1 } , y )$ 6 if $f$ is one-hot then 7 $\\mathrm { h a r m } _ { l } \\gets ( z ^ { t - 1 } - \\chi ( l ) ) ^ { \\top } \\mathrm { g r a d }$ 8 else 9 $\\vert \\quad \\mathrm { h a r m } _ { l } \\gets ( z ^ { t - 1 } - \\tau ( l ) ) ^ { \\top } \\mathrm { g r a d }$ 10 end 11 $\\mathrm { h a r m } \\gets \\mathrm { h a r m } * \\mathrm { m a s k } - ( 1 - \\mathrm { m a s k } ) * \\infty$ 12 zt ← f (arg max(harm)) 13 end 14 return z0 ← zl ",
+        "bbox": [
+            158,
+            107,
+            818,
+            357
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Input: Image $x$ , label $y$ , discretization function $f$ , loss $\\mathbb { L } ( \\pmb \\theta , f ( x ) , y )$ , $l$ attack steps, parameters ε, δ Output: Adversarial input to the network $z ^ { \\prime }$ $\\mathrm { m a s k }  g e t M a s k ( x , \\varepsilon )$ $u ^ { 0 } \\gets \\left( \\mathcal { N } ( \\mathbf { 0 } ^ { k } ; \\mathbf { 1 } ^ { k } ) \\right) ^ { n } * \\mathrm { m a s k - } \\left( 1 - \\mathrm { m a s k } \\right) * \\infty$ 3 T ← 1 if $f$ is one-hot then 5 F ← I 6 else 7 F ← C 8 8 end 9 z 0 ← F \u0010 σ \u0010 u 0T \u0011\u0011 10 for $t \\gets 1$ to $l$ do 11 grad ← ∇ut−1 L(θ, zt−1, y) 12 ut ← ut−1 + ξ · sign (grad) 13 z t ← F \u0010 σ \u0010 u tT \u0011\u0011 14 T ← T · δ 15 end 16 return $z ^ { \\prime } \\gets \\tau ( \\arg \\operatorname* { m a x } ( u _ { i } ^ { l } ) )$ ",
+        "bbox": [
+            156,
+            393,
+            821,
+            695
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4a5f1d75cd1f4ec8cdc637a606aff4ff207bd741d258c9ac806a1099e0c742f.jpg",
+        "table_caption": [
+            "Algorithm 2: Discrete Gradient Ascent (DGA) ",
+            "Algorithm 3: Logit-Space Projected Gradient Ascent (LS-PGA) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>m</td><td rowspan=1 colspan=1>8</td><td rowspan=1 colspan=1>White-box</td><td rowspan=1 colspan=1>Black-box</td></tr><tr><td rowspan=1 colspan=1>One-hotOne-hotOne-hot</td><td rowspan=1 colspan=1>1.00.0011.0</td><td rowspan=1 colspan=1>1.21.21.0</td><td rowspan=1 colspan=1>93.0893.5093.02</td><td rowspan=1 colspan=1>98.3998.4298.21</td></tr><tr><td rowspan=1 colspan=1>ThermometerThermometerThermometer</td><td rowspan=1 colspan=1>1.00.0011.0</td><td rowspan=1 colspan=1>1.21.21.0</td><td rowspan=1 colspan=1>93.7493.8893.75</td><td rowspan=1 colspan=1>98.4598.2498.22</td></tr></table>",
+        "bbox": [
+            302,
+            724,
+            696,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Table 6: Comparison of adversarial robustness to white-box attacks on MNIST using 16 levels and with various choices of the hyperparameters $\\xi$ and $\\delta$ for Algorithm 3. The models are evaluated on white-box attacks and on black-box attacks using a vanilla, clean trained model; both use LS-PGA. ",
+        "bbox": [
+            176,
+            843,
+            825,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Finally, we also trained on a mix of clean and adversarial examples: this resulted in significantly higher accuracy on clean examples, but decreased accuracy on white-box and black-box attacks compared to Tables 2 and 3. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/8dff75a34840b26f9a1b97493fe67a50efc6ec06f78efbecf976fdfc68640b21.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Clean</td><td>FGSM</td><td>PGD/LS-PGA</td></tr><tr><td>Vanilla</td><td>99.03</td><td>95.70</td><td>91.36</td></tr><tr><td>One-hot</td><td>99.01</td><td>96.14</td><td>93.77</td></tr><tr><td>Thermometer</td><td>99.13</td><td>96.10</td><td>93.70</td></tr></table>",
+        "bbox": [
+            318,
+            165,
+            679,
+            227
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 7: Comparison of adversarial robustness to white-box attacks on MNIST using a mix of clean and adversarial examples. ",
+        "bbox": [
+            171,
+            237,
+            825,
+            266
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/4c0220dfbbe8ed185054cb9d4b4e066db77bf10124e8ae7fee3bffdffe7db687.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Source Target</td><td colspan=\"3\">Clean</td><td colspan=\"3\">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td>Vanilla</td><td>97.88</td><td>97.87</td><td>96.99</td><td>93.07</td><td>90.97</td><td>96.46</td></tr><tr><td>One-hot</td><td>98.28</td><td>98.83</td><td>98.08</td><td>95.73</td><td>95.96</td><td>97.25</td></tr><tr><td>Thermometer</td><td>98.45</td><td>98.70</td><td>98.08</td><td>96.35</td><td>95.72</td><td>96.97</td></tr></table>",
+        "bbox": [
+            174,
+            305,
+            846,
+            382
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 8: Comparison of adversarial robustness to black-box attacks on MNIST of various models using a mix of clean and adversarial examples. ",
+        "bbox": [
+            176,
+            392,
+            823,
+            421
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/531a6e3885d10538d93dcfcbbfbe593a9426769fdd4e8b3e745268b79f1325a5.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td></td><td>White-box</td><td colspan=\"2\">Black-box</td></tr><tr><td>Levels</td><td>Clean</td><td>PGD/LS-PGA</td><td>Vanilla, Clean</td><td>Vanilla, PGD</td></tr><tr><td>One-hot (4) One-hot (8) One-hot (16)</td><td>99.09 99.10 99.14</td><td>92.95 92.65 93.08</td><td>98.23 98.49 98.39</td><td>95.64 96.37</td></tr><tr><td>One-hot (32) One-hot (64)</td><td>99.06 98.89</td><td>93.51 93.63</td><td>98.38 98.35</td><td>96.26 95.78</td></tr><tr><td>Thermometer (4)</td><td></td><td></td><td></td><td>95.74</td></tr><tr><td></td><td>99.11</td><td>92.62</td><td>98.23</td><td>95.67</td></tr><tr><td>Thermometer (8)</td><td>99.08</td><td>93.45</td><td>98.44</td><td>95.93</td></tr><tr><td>Thermometer(16)</td><td>99.07</td><td>93.88</td><td>98.24</td><td>95.28</td></tr><tr><td>Thermometer (32)</td><td>99.02</td><td>94.14</td><td>98.24</td><td>95.49</td></tr><tr><td>Thermometer (64)</td><td>99.00</td><td>94.62</td><td>98.33</td><td></td></tr><tr><td></td><td></td><td></td><td></td><td>95.71</td></tr></table>",
+        "bbox": [
+            220,
+            460,
+            777,
+            638
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 9: Comparison of adversarial robustness on MNIST as the number of levels of discretization is varied. All models are trained mix of adversarial examples and clean examples. ",
+        "bbox": [
+            173,
+            647,
+            825,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "D ADDITIONAL EXPERIMENTS ON CIFAR-10 ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            708,
+            571,
+            726
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In this section we list the additional experiments we performed on CIFAR-10. Firstly, we trained models on a mix of both clean and adversarial examples. The results for mixed training are listed in Tables 10 and 11; as expected it has lower accuracy on adversarial examples, but higher accuracy on clean examples, compared to training on only adversarial examples (Tables 4 and 5). ",
+        "bbox": [
+            174,
+            742,
+            826,
+            801
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/06348496e2bf1cad96212f0782932cc7eac427a4bf8dccac0d15e472f8d81f6d.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Clean</td><td>FGSM</td><td>PGD/LS-PGA</td></tr><tr><td>Vanilla</td><td>87.16</td><td>54.50</td><td>34.71</td></tr><tr><td>One-hot</td><td>92.19</td><td>58.87</td><td>58.96</td></tr><tr><td>Thermometer</td><td>92.32</td><td>66.60</td><td>65.67</td></tr></table>",
+        "bbox": [
+            318,
+            819,
+            678,
+            881
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Table 10: Comparison of adversarial robustness to white-box attacks on CIFAR-10 of various models using a mix of regular and adversarial training. ",
+        "bbox": [
+            173,
+            891,
+            825,
+            920
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/298c131e1d0daa7174cd2fa7173a98273278f14f3291b7ea0bf1b7b11f4134f5.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 11: Comparison of adversarial robustness to black-box attacks on CIFAR-10 of various models using a mix of clean and adversarial examples. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Source Target</td><td colspan=\"3\">Clean</td><td colspan=\"3\">Adv. train</td></tr><tr><td>Vanilla</td><td>One-hot</td><td>Thermometer</td><td>Vanilla</td><td>One-hot</td><td>Thermometer</td></tr><tr><td colspan=\"2\">Vanilla</td><td>83.62</td><td>82.06</td><td>74.31</td><td>52.83</td><td>58.73</td><td>65.24</td></tr><tr><td colspan=\"2\">One-hot</td><td>88.16</td><td>75.11</td><td>75.49</td><td>61.89</td><td>59.17</td><td>69.73</td></tr><tr><td colspan=\"2\">Thermometer</td><td>87.50</td><td>75.91</td><td>74.84</td><td>61.39</td><td>58.51</td><td>68.22</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            848,
+            178
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In order to explore whether the number of levels of discretization affected the performance of the model, we trained several models which varied this number. As expected, we found that models with fewer levels had worse accuracy on clean examples, likely because there was not enough information to correctly classify the image, but greater robustness to adversarial examples, likely because larger buckets mean a greater chance that a given perturbation will not yield any change in input to the network (Xu et al., 2017). Results can be seen in Tables 12, and are visualized in Figure 4. ",
+        "bbox": [
+            173,
+            238,
+            826,
+            324
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/8e511db505e6d2bf59d63cc10802c009a296b34356ddb7d347df476ba1b1b1eb.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 12: Comparison of adversarial robustness on CIFAR-10 as the number of levels of discretization is varied. All models are trained only on adversarial examples. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>White-box</td><td rowspan=1 colspan=2>Black-box</td></tr><tr><td rowspan=1 colspan=1>Levels</td><td rowspan=1 colspan=1>Clean</td><td rowspan=1 colspan=1>PGD/LS-PGA</td><td rowspan=1 colspan=1>Vanilla, Clean</td><td rowspan=1 colspan=1>Vanilla, PGD</td></tr><tr><td rowspan=1 colspan=1>Vanilla (Madry)</td><td rowspan=1 colspan=1>87.3</td><td rowspan=1 colspan=1>50.00</td><td rowspan=1 colspan=1>85.60</td><td rowspan=1 colspan=1>67.00</td></tr><tr><td rowspan=1 colspan=1>One-hot (4)One-hot (8)One-hot (16)One-hot (32)One-hot (64)</td><td rowspan=1 colspan=1>83.6785.6288.5488.5689.63</td><td rowspan=1 colspan=1>59.5961.9867.8367.8265.63</td><td rowspan=1 colspan=1>83.0384.9286.0185.6986.94</td><td rowspan=1 colspan=1>72.0372.1061.9266.6465.77</td></tr><tr><td rowspan=1 colspan=1>Thermometer (4)Thermometer (8)Thermometer (16)Thermometer (32)Thermometer (64)</td><td rowspan=1 colspan=1>84.4785.1789.8890.3089.95</td><td rowspan=1 colspan=1>61.8867.2379.1672.9169.37</td><td rowspan=1 colspan=1>83.6483.4188.2586.0683.85</td><td rowspan=1 colspan=1>72.9671.1167.9659.3251.82</td></tr></table>",
+        "bbox": [
+            222,
+            335,
+            776,
+            529
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "E EXPERIMENTS ON CIFAR-100 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            593,
+            464,
+            611
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We list the experimental results on CIFAR-100 in Table 13. We choose $\\xi = 0 . 0 1$ and $\\delta = 1 . 2$ for the LS-PGA attack hyperparameters. For the discretized models, we used 16 levels. All adversarially trained models were trained on a mix of clean and adversarial examples. ",
+        "bbox": [
+            173,
+            625,
+            826,
+            667
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/356228d43d1253142c4279ed0548c077ec6b9be7062e52e591f0b11f6be8dab7.jpg",
+        "table_caption": [
+            "Table 13: Comparison of adversarial robustness on CIFAR-100. All adversarially trained models were trained on a mix of clean and adversarial examples. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td rowspan=\"2\">Source</td><td rowspan=\"2\">Clean</td><td rowspan=\"2\">White-box PGD/LS-PGA</td><td colspan=\"2\">Black-box</td></tr><tr><td>Vanilla, Clean-trained</td><td>Vanilla, PGD-trained</td></tr><tr><td>evaaa</td><td>Vanilla One-hot</td><td>74.32</td><td>0</td><td>0.4</td><td>9.40</td></tr><tr><td rowspan=\"3\"></td><td>Thermometer</td><td>73.25</td><td>16.55</td><td>55.72</td><td>19.33</td></tr><tr><td></td><td>74.44</td><td>16.50</td><td>50.33</td><td>18.49</td></tr><tr><td>Vanilla</td><td>64.46</td><td>6.02</td><td>7.46</td><td>11.77</td></tr><tr><td rowspan=\"2\">A</td><td>One-hot</td><td>66.54</td><td>25.11</td><td>63.09</td><td>42.46</td></tr><tr><td>Thermometer</td><td>68.44</td><td>28.14</td><td>63.21</td><td>41.97</td></tr></table>",
+        "bbox": [
+            173,
+            679,
+            843,
+            801
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "F EXPERIMENTS ON SVHN ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            864,
+            419,
+            881
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We list the experimental results on SVHN in Table 14. All adversarially trained models were trained only on adversarial examples. ",
+        "bbox": [
+            173,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "table",
+        "img_path": "images/7fe342043f5eafcec1d51ce39a63be8d4aeb4ad8e0b06c44b77d430e2dcfbe5c.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 14: Comparison of adversarial robustness on SVHN. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Target</td><td rowspan=\"2\">Source</td><td></td><td>White-box</td><td colspan=\"2\">Black-box</td></tr><tr><td>Clean</td><td>PGD/LS-PGA</td><td>Vanilla, Clean-trained</td><td>Vanilla, PGD-trained</td></tr><tr><td>erea</td><td>Vanilla</td><td>97.90</td><td>6.99</td><td>73.94</td><td>42.04</td></tr><tr><td rowspan=\"3\"></td><td>One-hot</td><td>97.59</td><td>56.02</td><td>75.77</td><td>41.59</td></tr><tr><td>Thermometer</td><td>97.87</td><td>56.37</td><td>78.04</td><td>41.69</td></tr><tr><td>Vanilla</td><td>94.79</td><td>59.63</td><td>81.24</td><td>46.77</td></tr><tr><td rowspan=\"2\">A</td><td>One-hot</td><td>95.12</td><td>87.34</td><td>83.84</td><td>43.40</td></tr><tr><td>Thermometer</td><td>97.74</td><td>94.77</td><td>84.97</td><td>48.67</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            843,
+            222
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "G SUPPLEMENTARY FIGURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            272,
+            436,
+            289
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8ebdd6c09562c3bff5cb9abe039c9d87ccd31689672f17c3dd1b5d3353ae4be.jpg",
+        "image_caption": [
+            "In Figure 4 we plot the effect of increasing the levels of discretization for the MNIST and CIFAR-10 datasets. ",
+            "Figure 4: The effect of increasing the number of distinct discretization levels on the accuracy of the model on MNIST and CIFAR-10. (4a) shows the accuracy on on MNIST for discretized models trained on a mix of legitimate and adversarial examples. (4b) shows the accuracy on CIFAR-10 for discretized models trained only on adversarial examples. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            339,
+            807,
+            518
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Figure 5 we plot the convergence rate of clean trained and adversarially trained models on the CIFAR-10 dataset. Note that thermometer encoded inputs converge much faster in accuracy on both clean and adversarial inputs. ",
+        "bbox": [
+            176,
+            602,
+            820,
+            645
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Figure 6 plots the norm of the gradient as a function of the number of iterations of the attack on MNIST. Note that the gradient vanishes at around 40 iterations, which coincides with the loss stabilizing in Figure 3. ",
+        "bbox": [
+            176,
+            651,
+            821,
+            693
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Figure 7, we create a linear interpolation between a clean image and an adversarial example, and then continue to extrapolate along this line, evaluating probability of each class at each point. In models trained on unquantized inputs, the class probabilities are all mostly piecewise linear in both the positive and negative directions. In contrast, the discretized model has a much more jagged and irregular shape. ",
+        "bbox": [
+            174,
+            700,
+            825,
+            770
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Figure 8, we plot the error for different models on various values of $\\varepsilon$ . The discretized models are extremely robust to all values less-than-or-equal-to the values that they have been exposed to during training. However, beyond this threshold, discretized models collapse immediately, while real-valued models still maintain some semblance of robustness. This exposes a weakness of the discretization approach; the same nonlinearity that helps it learn to become robust to all attacks it sees during training-time causes its behavior is unpredictable beyond that. ",
+        "bbox": [
+            174,
+            776,
+            825,
+            861
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "However, we believe that the fact that the performance of thermometer-encoded models degrades more quickly than that of vanilla models beyond the training epsilon is a significant weakness in practice, but no worse than other defenses. The “standard setting” for the adversarial example problem (in which we constrain the L-infinity norm of the perturbed image to an epsilon ball around the original image) was designed to ensure that any adversarially-perturbed image is still recognizable as its original image by a human. However, this artificial constraint excludes many other potential attacks that also result in human-recognizable images. State-of-the art defenses in the standard setting can still be easily defeated by non-standard attacks; for an example of this, see appendix A of ICLR submission “Adversarial Spheres”. A “larger epsilon” attack is just one special case of a “non-standard” attack. If we permit non-standard attacks, a fair comparison would show that all current approaches are easily breakable. There is nothing special about the “larger epsilon” attack that makes a vulnerability to this non-standard attack in particular more problematic than vulnerabilities to other non-standard attacks. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/f54afb62fd3df9546cc33fc79e2f193ef3b221d2ab127c90e7d8126cc8b84224.jpg",
+        "image_caption": [
+            "Figure 5: Comparison of the convergence rate of various adversarially trained models on the CIFAR-10 dataset. The discretized models use 16 levels per color channel. (5a) shows the accuracy on clean examples, while (5b) shows the accuracy on white-box PGD/LS-PGA examples, in wall-clock time. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            99,
+            820,
+            295
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/26d31999144179f1b87e876690579d277bda1d16fe9adca44b3657d0a5e4dc09.jpg",
+        "image_caption": [
+            "Figure 6: Gradient norm for iterated white-box attacks on various models on a randomly chosen data point from MNIST. (6a) shows the gradient norm on discretized models as a function of steps of LS-PGA, while (6b) shows the gradient norm on a vanilla model as a function of steps of PGD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            378,
+            815,
+            571
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            651,
+            825,
+            777
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Figures 9, 10 , 11, 12 , 13 and 14 we plot several examples of church-window plots for MNIST (Goodfellow et al., 2014). Each plot is crafted by taking several test-set images, calculating the vector corresponding to an adversarial attack on each image, and then choosing an additional random orthogonal direction. In each plot, the clean image is at the center and corresponds to the color white, the $x$ -axis corresponds to the magnitude of a perturbation in the adversarial direction, and the $y$ -axis corresponds to the magnitude of a perturbation in the orthogonal direction. Note that we use the same random seed to generate the test set examples and the adversarial directions across different church-window plots. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            896
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/0604ba8d594b2cc20ab2cd825ddd95d7f109060c47f4da6bd6c0c716b6cb48a4.jpg",
+        "image_caption": [
+            "Figure 7: Linear extrapolation plot as in Goodfellow et al. (2014) for MNIST. (7a) shows the behavior of a vanilla model while (7b) for a discretized model using 16 levels and thermometer encoding. The $\\varepsilon$ -bound is $[ - 1 . 5 , 1 . 5 ]$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            192,
+            189,
+            823,
+            386
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/c78f8a5fe014e2f444bb58892bc5fb5cb13c6cf56a7ada4884d05a07ae541f0a.jpg",
+        "image_caption": [
+            "Figure 8: Plot showing the accuracy of various adversarially trained models on MNIST with $\\varepsilon =$ 0.3 (8a) and on CIFAR-10 with $\\varepsilon = 0 . 0 3 1$ (8b), when attacked with increasing values of $\\varepsilon$ using PGD/LS-PGA. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            597,
+            825,
+            792
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/d1f6655e799c3df8ee0c7d91633ddd42647398284e1ce47bb635c2f380feca43.jpg",
+        "image_caption": [
+            "Figure 9: Church-window plots of clean-trained models on MNIST. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on nondiscretized models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            190,
+            821,
+            733
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/a7c9b35d39f9aae5b0e758c5718f5e087620a70b03f03c951a8a59a7f1b044b2.jpg",
+        "image_caption": [
+            "Figure 10: Church-window plots of adversarially-trained models on MNIST, trained on only adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            200,
+            821,
+            739
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/f110fa7dc03c228647aad430e7c23c0aa9d8f9045ebe745e79b586287148d078.jpg",
+        "image_caption": [
+            "Figure 11: Church-window plots of adversarially-trained models on MNIST, trained using a mix of clean and adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on non-discretized models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            193,
+            821,
+            734
+        ],
+        "page_idx": 18
+    },
+    {
+        "type": "image",
+        "img_path": "images/de62ebb60756bab3e9b9f0d3e2a7a522816c61a5478d63537904a6753e8ba708.jpg",
+        "image_caption": [
+            "Figure 12: Church-window plots of clean-trained models on CIFAR-10. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on nondiscretized models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            189,
+            821,
+            733
+        ],
+        "page_idx": 19
+    },
+    {
+        "type": "image",
+        "img_path": "images/533fb3c9d3296390750f7f7c0d5de121e121313c39a27778531efd51f4a48fb9.jpg",
+        "image_caption": [
+            "Figure 13: Church-window plots of adversarially-trained models on CIFAR-10, trained on only adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y \\cdot$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            95,
+            821,
+            638
+        ],
+        "page_idx": 20
+    },
+    {
+        "type": "image",
+        "img_path": "images/a379953bd90bdb3939721bdba8051da89b967e596d108733d52c8302e4f8dc62.jpg",
+        "image_caption": [
+            "Figure 14: Church-window plots of adversarially-trained models on CIFAR-10, trained using a mix of clean and adversarial examples. The $x$ -axis of each sub-plot represents the adversarial direction, while the $y$ -axis represents a random orthogonal direction. The correct class is represented by white. Every row in the plot contains a training data point chosen uniformly at random, while each column uses a different random orthogonal vector for the $y$ -axis. The $\\varepsilon$ bound for both axes is $[ - 1 . 0 , 1 . 0 ]$ . Notice the almost-linear decision boundaries on non-discretized models. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            189,
+            821,
+            734
+        ],
+        "page_idx": 21
+    }
+]

parse/train/S1gE6TEYDB/S1gE6TEYDB.md

@@ -0,0 +1,328 @@
+# GLOBAL REASONING NETWORK FOR IMAGE SUPERRESOLUTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Recent image super-resolution(SR) studies leverage very deep convolutional neural networks and the rich hierarchical features they offered, which leads to better reconstruction performance than conventional methods. However, the small receptive fields in the up-sampling and reconstruction process of those models stop them to take full advantage of global contextual information. This causes problems for further performance improvement. In this paper, inspired by image reconstruction principles of human visual system, we propose an image super-resolution global reasoning network (SRGRN) to effectively learn the correlations between different regions of an image, through global reasoning. Specifically, we propose global reasoning up-sampling module (GRUM) and global reasoning reconstruction block (GRRB). They construct a graph model to perform relation reasoning on regions of low resolution (LR) images.They aim to reason the interactions between different regions in the up-sampling and reconstruction process and thus leverage more contextual information to generate accurate details. Our proposed SRGRN are more robust and can handle low resolution images that are corrupted by multiple types of degradation. Extensive experiments on different benchmark data-sets show that our model outperforms other state-of-the-art methods. Also our model is lightweight and consumes less computing power, which makes it very suitable for real life deployment.
+
+# 1 INTRODUCTION
+
+Image Super-Resolution (SR) aims to reconstruct an accurate high-resolution (HR) image given its low-resolution (LR) counterpart. It is a typical ill-posed problem, since the LR to HR mapping is highly uncertain. In order to solve this problem, a large number of methods have been proposed, including interpolation-based (Zhang & Wu., 2006), reconstruction-based(Zhang et al., 2012), and learning-based methods (Timofte et al., 2013; 2014; Peleg & Elad., 2014; Schulter et al., 2015; Dong et al.; Huang et al., 2015; Tai et al., 2017; Tong et al., 2017; Zhang et al., 2018a; Dong et al., 2016).
+
+In recent years, deep learning based methods have achieved outstanding performance in superresolution reconstruction. Some effective residual or dense blocks (Huang et al., 2017; Zhang et al., 2018b; Wang et al., 2018; Lim et al., 2017; Ledig et al., 2017; Ahn et al.; Li et al., 2018) have been proposed to make the network wider and deeper and achieved better results. However, they only pay close attention to improving the feature extraction module, ignoring that the upsampling process with smaller receptive fields does not make full use of those extracted features. Small convolution receptive field means that the upsampling process can only perform super-resolution reconstruction based on local feature relationships in LR. As we all know, different features interact with each other, and features which are in different regions have corresponding effects on upsampling and reconstruction of a certain region. That is to say that a lot of information is lost in the process of upsampling and reconstruction due to the limitation of the receptive field, although the network extracts a large number of hierarchical features which are from low frequency to high frequency.
+
+Chariker et al. (2016; 2018) show that the brain generates the images we see based on a small amount of information observed by the human eye, ranther than acquiring the complete data from the point-by-point scan of the retina. This process of generating an image is similar to a SR process. According to their thought, we add global information in SR reconstruction and propose to use relational reasoning to implement the process that the human visual system reconstructs images with observed global information. In general, extracting global information requires a large receptive field. A large convolution receptive field usually requires stacking a large number of convolutional layers, but this method does not work in the upsampling and reconstruction process. Because this will produce a huge number of parameters.
+
+Based on the above analysis, we propose an image super-resolution global reasoning network (SRGRN) which introduces the global reasoning mechanism to the upsampling module and the reconstruction layer. The model can capture the relationship between disjoint features of the image with a small respective field, thereby fully exploits global information as a reference for upsampling and reconstruction. We mainly propose global reasoning upsampling module (GRUM) and global reasoning reconstruction block (GRRB) as the core structure of the network. GRUM and GRRB first convert the LR feature map into $N$ nodes, each of which not only represents a feature region in the LR image, but also contains the influence of pixels in other regions on this feature. Then they learn the relationship between the nodes and fuse the information of each node in a global scope. After that, GRUM learns the relationship between the channels in each node and amplifies the number of channels for the upsampling process. And then they convert $N$ nodes into pixels with global reasoning information. Finally, GRUM and GRRB complete the upsampling and reconstruction process respectively.
+
+In general, our work mainly has the following three contributions:
+
+• We propose an image super-resolution global reasoning network (SRGRN) which draws on the idea of image reconstruction principles of human visual system. We mainly focus on the upsampling module and the reconstruction module. The model reconstructs SR images based on relational reasoning in a global scope.   
+• We propose a global reasoning upsampling module (GRUM) and global reasoning reconstruction block (GRRB), which construct a graph model to implement the relational reasoning among the feature regions in an image via 1D and 2D convolution, and finally adds the information obtained by global reasoning to each pixel. It can provide more contextual information to help generate more accurate details.   
+• Our proposed GRUM and GRRB are lightweight, which makes it suitable for real life deployment. More importantly, GRUM and GRRB balance the number of parameters and the reconstruction performance well. They can be easily inserted into other models.
+
+# 2 RELATED WORKS
+
+Deep CNN for SR and upsampling methods. Deep learning has achieved excellent performance in image super-resolution tasks. For the first time, Dong et al. applied convolutional neural networks to image SR. After this, Kim et al. proposed VDSR (Kima et al., 2016) and DRCN (Kim et al., 2016) which introduced residual learning to make the network depth reach 20 layers achieved significant improvement. And then more and more researchers are starting to pay attention to the improvement of the network feature extraction part. Lim et al. (2017) proposed EDSR and MDSR, which introduce residual scaling and remove unnecessary modules from the residual block. Concerned that the previous models only adopt the feather of the last CNN, Zhang et al. (2018b) proposed residual dense network to make full use of hierarchical features from each Conv layer. The above and most of the subsequent networks implement the upsampling based on either transposed convolution (Zeiler et al., 2010; Zeiler & Fergus., 2014) or sub-pixel convolution (Shi et al., 2016). Although these models have achieved good results, there exists a problem that these upsampling methods have only a small receptive field. This means that upsampling can only take advantage of contextual information within a small area.
+
+Recently, researchers propose some new super-resolution upsampling process. LapSRN (Lai et al., 2017) allows low-resolution images to be directly input into the network for step-by-step amplification. Haris et al. (2018) exploit iterative up-and-down sampling layers and propose DBPN. Li et al. (2019) further explore the application of feedback mechanism (weight sharing) in SR and propose the SRFBN. These models have achieved a better reconstruction performance. However, the Conv layers in these upsampling modules still have only a small receptive field.
+
+Global reasoning machansim. Recently, graph-based deep learning methods have begun to be widely used to solve relation reasoning. Santoro et al. propose Relation Networks (RN) (Santoro et al., 2017) to solve problems that depend on relational reasoning. Liu et al. (2018) propose SIN, which implement a object detection using a graph model for structure inference. Furthermore, Chen et al. (2018) model a Global Reasoning unit that consists of five convolutions for image classification, semantic segmentation and video action recognition task. Considering that the human visual system generates images based on the observed global information is also a reasoning process. Moreover, correlation between feature regions can be obtained through relational reasoning, which makes each pixel in the generated SR image jointly determined by the information in a global scope. Therefore, we propose a global reasoning network for SR. We will detail our SRGRN in next section.
+
+# 3 PROPOSED MODEL
+
+According to Chariker et al. (2016; 2018), there is only little information transmitted from the retina to the visual cortex, and then the brain will reconstruct the real-world images based on the information received. We regard it as a reasoning process in a global scope. For image SR, the upsampling module constructs SR images base on features in LR images, which is substantially similar to detecting the category of each pixel of a SR image and generating these pixels based on contextual information of corresponding LR image. Due to the limitation of the convolution receptive field, only a small amount of contextual information can be utilized to generate HR images in most other models. This leads that many details in the HR image are not fine. Similarly, the above problem also exists in the reconstruction process. To solve these problems, we simulate the reasoning process that exists in human visual system, and then propose SRGRN to make full use of the contextual information to recover accurate details, which is achieved by constructing graph model and reasoning the relationship between these regions in an image.
+
+![](images/5b8a9e67a715c5cd8443b361a1c0e9d5fd46bb02632651a48a971d3280e16e07.jpg)  
+Figure 1: Super-resolution global reasoning network (SRGRN) architecture
+
+# 3.1 ARCHITECTURE
+
+As shown in Figure 1, our SRGRN includes feature extraction part, global reasoning upsample module(GRUM) and global reasoning reconstruction block(GRRB). Let’s denote $I _ { L R }$ and $I _ { S R }$ as the input and output of SRGRN. The feature extraction part can use the relevant architecture of most other models. Here we introduce the feature extraction part of the RDN (Zhang et al., 2018b) as an example.
+
+$$
+F _ { L } = H _ { F E X } ( I _ { L R } )
+$$
+
+where $H _ { F E X } ( \cdot )$ denotes a series of operations of feature extraction part.
+
+As with the previous work (Lim et al., 2017), the number of GRUM depends on the scaling factor, The GRUM receives $F _ { L }$ as input. $F _ { S }$ represents the output of the GRUM. GRUM can be expressed by the following mathematical formula:
+
+$$
+F _ { S } = H _ { G R U M } ( F _ { L } )
+$$
+
+where $H _ { G R U M } ( \cdot )$ denotes a series of operations of GRUM. More details about GRUM will be given in Section 3.2.
+
+We further conduct global reasoning reconstruction block(GRRB) to utilize the global contextual information to generate the output image. GRRB can be expressed by the following mathematical formula:
+
+$$
+I _ { S R } = H _ { G R R B } ( F _ { S } )
+$$
+
+where $H _ { G R R B } ( \cdot )$ denotes a series of operations of GRRB. More details about GRRB will be given in Section 3.3. After the above operations, we get the corresponding SR image.
+
+# 3.2 GLOBAL REASONING UPSAMPLING MODULE
+
+In this section, we present details about our proposed global reasoning upsample module(GRUM) in Figure 2. In order to help achieve relation reasoning, we map each image to a graph model
+
+![](images/8d146d61712d5799dbbf982bbb8c70d1dcd64de9d09447e116f6d5a2013ee935.jpg)  
+Figure 2: Global reasoning upsampling module (GRUM) architecture
+
+$G = ( V , E , u )$ , where nodes in graph represent different regions in the image, E represents the relationship weight between the different regions, stored in the adjacency matrix of the graph, and u is the global information of the entire image.
+
+We first need a function to construct $N$ nodes in the oriented graph, each of which represents a region in the image. In GRUM, we obtain relationship weights between these pixels through a 2D $1 \times 1$ convolution, and then convert the input $F _ { L }$ into $N$ nodes via element-wise product. The benefits of this approach are mainly reflected in the following aspects: (1) It can not only aggregates a feature region of the input $F _ { L }$ into a node, but also dig out the influence of other pixels in the image on this region. This is equivalent to adding global guidance of the image to each node. (2) Using convolution means that these relationship weights are trainable. This process can be expressed by the following mathematical formula:
+
+$$
+W _ { n } = V _ { d } ( C o n v ( F _ { L } ) )
+$$
+
+$$
+Y _ { W } = W _ { n } \cdot ( V _ { d } ( F _ { L } ) ) ^ { T }
+$$
+
+where $F _ { L } \in \mathbb { R } ^ { C \times H \times W }$ denotes the input tensor, $V _ { d } ( \cdot )$ denotes the operation of converting the vector shape from $N \times H \times W$ to $N { \times } H W$ , $\bar { W } _ { n } \in \mathbb { R } ^ { N \times H W }$ denotes relationship weights and $\boldsymbol { Y } _ { W } ^ { \mathbf { - } } \in \mathbb { R } ^ { N \times C }$ refers to $N$ nodes with C channels.
+
+After that, we use the 1D Conv - Leaky ReLu - 1D Conv (CLC) structure to implement reasoning and interaction between $N$ nodes in the graph. The parameters in CLC refer to the adjacency matrix of the weighted oriented complete graph, which store the correlations between the nodes. CLC can learn and reason the complex nonlinear relationship between nodes better than only one 1D Conv. We use the following formula to describe the reasoning process between nodes:
+
+$$
+Y _ { N } = C o n v ( L R e l u ( C o n v ( Y _ { W } ) ) )
+$$
+
+where $C o n v ( \cdot )$ and $L R e l u ( \cdot )$ denote 1D convolution along node-wise and Leaky ReLU (Maas et al., 2013) operation respectively.
+
+And then we use the bottleneck to achieve channel amplification. The bottleneck receives $Y _ { N } \in \cal { Y }$ $\mathbb { R } ^ { N \times C }$ as input and redistributes these channels by modeling the relationship between the channels of each node, amplifying the number of channel to $C \times r ^ { 2 }$ , where $\mathbf { r }$ is the upscaling factor.
+
+The first convolution in bottleneck makes channel C drop to $\bar { C } = C / \alpha$ , where $\alpha$ represents reduction ratio. Then the second convolution makes the channel dimension $\bar { C }$ grow to $C \times \bar { r } ^ { 2 }$ . The bottleneck not only fits the complex relationships between channels better and redistributes channels more accurately, but also greatly reduces the number of parameters compared to the method of utilizing a single convolution. We use the following formula to describe channel amplification:
+
+$$
+Y _ { N C } = C o n v ( L R e l u ( C o n v ( ( Y _ { N } ) ^ { T } ) ) )
+$$
+
+where $Y _ { N C } \in \mathbb { R } ^ { r ^ { 2 } C \times N }$ refers to the output tensor.
+
+In order to expand the resolution by pixelshuffle like ESPCN (Shi et al., 2016), we need to retransform the $N$ nodes $( r ^ { 2 } C \times N )$ which have implemented the relational reasoning into a space whose shape is $C \times H \times W$ . As above, we still learn a function to get a weight matrix whose shape is $N \times H W$ through a $1 \times 1$ 2D convolution, and then normalize the weight matrix along the column with softmax. Finally, $Y _ { r C }$ and $W _ { P }$ can be obtained through:
+
+$$
+W _ { P } = S o f t m a x ( V _ { d } ( C o n v ( F _ { L } ) ) )
+$$
+
+$$
+Y _ { r C } = V _ { u } ( Y _ { N C } W _ { P } )
+$$
+
+where $V _ { u } ( \cdot )$ denotes the operation of reshaping $N \times H W$ to $N \times H \times W$ . $Y _ { r C } \in \mathbb { R } ^ { r ^ { 2 } C \times H \times W }$ is a ·feature map where each pixel is associated with $N$ ×nodes. $W _ { P } \in \mathbb { R } ^ { N \times H W }$ ∈is the normalized weight matrix. The value of these weights ranges from 0 to 1. This means that the reconstruction of each pixel is affected by $N$ nodes to varying degrees. Each pixel in the feature map contains information which is generated by global reasoning.
+
+After pixelshuffle, the output is multiplied by a parameter $\gamma _ { 1 }$ and added to the upsampling result without global reasoning. The initial value of $\gamma _ { 1 }$ is set to 0. As the global reasoning module trains, the network will gradually learn to assign values to the $\gamma _ { 1 }$ , thereby fully exploiting global reasoning. This process can be expressed by the following formula:
+
+$$
+Y _ { S } = H _ { P S } ( Y _ { r C } ) \cdot \gamma _ { 1 } + H _ { U P } ( F _ { L } ) \cdot ( 1 - \gamma _ { 1 } )
+$$
+
+where $H _ { P S } ( \cdot )$ denotes the operations of pixel shuffle and $H _ { U P } ( \cdot )$ denotes the operations of subpixel convolution.
+
+Finally, $F _ { S }$ can be obtained by:
+
+$$
+F _ { S } = C o n v ( Y _ { S } )
+$$
+
+![](images/6f54f4278a32a0e4c886e29bc1188ed4c638443e18ddbc339d7009f15e6fd534.jpg)  
+Figure 3: Global reasoning reconstruction block (GRRB) architecture
+
+# 3.3 GLOBAL REASONING RECONSTRUCTION BLOCK
+
+As shown in Figure 3, the specific details are similar to GRUM. We also construct a graph model for reconstruction block.
+
+In GRRB, we first obtain the relationship weights $W _ { R N } \in \mathbb { R } ^ { N \times r H r W }$ between pixels of $F _ { S }$ by 2D 1x1 convolution, and then aggregate the regions in $F _ { S }$ into $N$ nodes by element-wise product. The output of this process $\boldsymbol { Y } _ { R W } \in \mathbb { R } ^ { \boldsymbol { N } \times \boldsymbol { C } }$ can be formulated as:
+
+$$
+\begin{array} { r } { Y _ { R W } = W _ { R N } \cdot ( V _ { d } ( F _ { S } ) ) ^ { T } = V _ { d } ( C o n v ( F _ { S } ) ) \cdot ( V _ { d } ( F _ { S } ) ) ^ { T } } \end{array}
+$$
+
+After that, we use CLC to achieve the relationship reasoning between nodes. Then we exploit the weight matrix $W _ { R P } \in \mathbb { R } ^ { N \times r H r W } = \acute { S o f t m a x } ( V _ { d } ( C o n \bar { v } ( F _ { S } ) ) )$ obtained by learning to redistribute the information of $N$ nodes to the pixels. The output of this process $Y _ { R r C } \mathbf { \dot { \in } } \mathbb { R } ^ { C \times r \mathbf { \widecheck { H } } \times r W }$ can be obtained by:
+
+$$
+Y _ { R r C } = V _ { u } ( ( F _ { C L C } ( Y _ { R W } ) ) ^ { T } \cdot W _ { R P } ) = V _ { u } ( ( F _ { C L C } ( Y _ { R W } ) ) ^ { T } \cdot S o f t m a x ( V _ { d } ( C o n v ( F _ { S } ) ) ) )
+$$
+
+where $F _ { C L C }$ refers to the operations of CLC. In addition, we apply the idea of residual connection in GRRB, which multiplys the information generated via global reasoning by a parameter $\gamma$ and then add it to the input feature map. The output is given by:
+
+$$
+Y _ { R S } = \gamma \cdot Y _ { R r C } + F _ { S }
+$$
+
+The initial value of $\gamma$ is set to 0. As the training progresses, the network assigns more weight to $\gamma$ . Finally, we input the feature map with global reasoning into the two Convs for reconstruction. We can get the final output through:
+
+$$
+I _ { S R } = H _ { R L } ( Y _ { R S } )
+$$
+
+where $H _ { R L } ( \cdot )$ denotes the operations of two Convs.
+
+# 3.4 IMPLEMENTATION DETAILS
+
+In our proposed SRGRN, like the previous method (Lim et al., 2017), the number of GRUM depends on the scaling factor. For Conv layers with kernel size $3 \times 3$ , we pad zeros to keep size fixed. We set the reduction ratio in bottleneck as $\alpha$ . The number of nodes in the graph model is set to N. We utilize Leaky ReLu (Maas et al., 2013) with a negative slope of 0.2 as non-linear activation function. The feature extraction part of the network are the same as the RDN (Zhang et al., 2018b) settings. The final Conv layer has 1 or 3 output channels, as we output gray or color HR images.
+
+# 4 EXPERIMENTS
+
+# 4.1 SETTINGS
+
+Datasets and Metrics. We train all our models using 800 training images in the DIV2K (Agustsson & Timofte., 2017) dataset, which contains high-quality 2K images that can be used for image superresolution task. And We use five standard benchmark datasets to evaluate PSNR and SSIM (Wang et al., 2004) metrics: Set5 (Bevilacqua et al., 2012), Set14 (Zeyde et al., 2010), B100 (Martin et al., 2001), Urban100 (Huang et al., 2015) and Manga109 (Y.Matsui et al., 2017). The SR results are evaluated on Y channel of transformed YCbCr space.
+
+Degradation Models. In order to make a fair comparison with existing models, bicubic dowmsampling(denoted as BI) is regarded as a standard degradation model. We use it to generate LR images with scaling factor $\times 2$ , $\times 3$ , and $\times 4$ from ground truth HR images. To fully demonstrate the effectiveness of our model, we also use two other degradation models and conduct special experiments for them. Our second model, we defined it as BD, which blurs HR images with a Gaussian kernel of size $7 \times 7$ and a standard deviation of 1.6, and then downsamples the image with scaling factor $\times 3$ In addition to BI and BD, we also built the DN model, which first performs bicubic downsampling with scaling factor $\times 3$ and then adds Gaussian noise with a noise level of 30.
+
+Training Setting. In each training batch, 16 LR RGB patches of size $4 8 \times 4 8$ are extracted as inputs. We perform data enhancement on the training images, which are randomly rotated by $9 0 °$ , $1 8 0 ^ { \circ }$ , $2 7 0 ^ { \circ }$ and flipped horizontally. We use the Adam optimizer to update the parameters of the network with $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ , and $\epsilon = 1 0 ^ { - 8 }$ . For all layers in the network, the initial learning rate is set to 0.0001, and then the learning rate is halved every 200 epochs. We use the Pytorch framework to implement our model with Tesla P100.
+
+# 4.2 ABLATION INVESTIGATION AND STUDY OF PARAMETERS
+
+Global reasoning upsampling module. In order to verify the importance of the GRUM, we remove the GRUM from the network, leaving only the GRRB in the network for relation reasoning. As shown in Table 1, after removing GRUM, the performance of the network drops from $3 2 . 4 5 { \mathrm { ~ d B } }$ to $3 2 . 4 0 ~ \mathrm { d B }$ . When the Case Index is equal to 1, the corresponding model is the baseline model. We can observe that after GRUM is added to the baseline model, the network performance is improved from 32.31 dB to $3 2 . 4 2 \ : \mathrm { d B }$ . It can be seen that although our baseline model has achieved quite good results, GRUM can still improve the performance by relation reasoning in upsample module. This also indicates that relation reasoning can indeed result in better prformance. These comparisons fairly demonstrate the effectiveness of the GRUM for SR tasks.
+
+Global reasoning reconstruction block. Then, we continue to study the effectiveness of GRRB for the network. After we add the GRRB to the baseline model, GRRB improves the performance of the model from 32.31 dB to $3 2 . 4 0 ~ \mathrm { d B }$ . Furthermore, the model with GRUM has achieved good performance. And it is difficult to obtain further improvements. But when we add the GRRB to it, the network performance shows a significant improvement, and the PSNR value on Set5 increases from 32.42 dB to 32.45 dB. These indicates that it is very essential for our network.
+
+Basic parameters. Moreover, we also study the effects of two basic parameters $N$ and $\alpha$ on the performance of the model. As shown in Table 1, we observe that larger $N$ and smaller $\alpha$ would lead to higher performance. Considering that larger $N$ and smaller $\alpha$ will also bring more computation, we set 10 and 8 as the value of $N$ and $\alpha$ respectively.
+
+Table 1: Ablation investigation of global reasoning upsampling method and global reasoning reconstruction block, study of $\mathbf { N }$ and $\alpha$ . We observe the best PSNR values on Set5 with scaling factor $\times 4$ in 200 epochs   
+
+<table><tr><td>CaseIndex</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr><td>Global reasoning upsampling module Global reasoning reconstruction block</td><td>×</td><td>√</td><td>×</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>Number of Node (N)</td><td>× -</td><td>× 10</td><td>√ 10</td><td>√ 10</td><td>√ 8</td><td>√ 6</td><td>√ 8</td><td>√ 6</td></tr><tr><td>reduction ratio (α)</td><td>-</td><td>8</td><td>8</td><td>8</td><td>8</td><td>8</td><td>16</td><td>16</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PSNRonSet5 (4×)</td><td>32.31</td><td>32.42</td><td>32.40</td><td>32.45</td><td>32.43</td><td>32.42</td><td>32.42</td><td>32.40</td></tr></table>
+
+# 4.3 NETWORK PARAMETERS
+
+Several state-of-the-art methods are compared with our SRGRN in this section. We show comparisons about model size and performance in Figure 4. Although our SRGRN has less parameter
+
+number than that of EDSR, MDSR and D-DBPN, our SRGRN and ${ \mathrm { S R G R N } } +$ achieve higher performance, having a better tradeoff between model size and performance. This demonstrates our method can well balance the number of parameters and the reconstruction performance.
+
+![](images/fa0afa494b6350f18c6b633ca24483caf93fa8cea5b841529c6ffdd565fc5a42.jpg)  
+Figure 4: The results are evaluated on the Set5 dataset for $4 \times \mathrm { S R }$ . The proposed SRGRN strikes a balance between the number of parameters and the reconstruction effect.
+
+Table 2: Average PSNR/SSIM for scale factors $\times 2$ , $\times 3$ and $\times 4$ with BI degradation model. Best results are highlighted   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">scale</td><td colspan="2">Set5</td><td colspan="2">Set14</td><td colspan="2">BSDS100</td><td colspan="2">Urban100</td><td colspan="2">Manga109</td></tr><tr><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td rowspan="9"></td><td>33.66</td><td>0.9299</td><td>30.24</td><td>0.8688</td><td>29.56</td><td>0.8431</td><td>26.88</td><td>0.8403</td><td>30.80</td><td>0.9339</td></tr><tr><td>SRCNN</td><td>36.66</td><td>0.9542</td><td>32.45</td><td>0.9067</td><td>31.36</td><td>0.8879</td><td>29.50</td><td>0.8946</td><td>35.60</td><td>0.9663</td></tr><tr><td>DRRN</td><td>37.74</td><td>0.9591</td><td>33.23</td><td>0.9136</td><td>32.05</td><td>0.8973</td><td>31.23</td><td>0.9188</td><td>37.60</td><td>0.9736</td></tr><tr><td>LapSRN</td><td>37.52</td><td>0.9591</td><td>33.08</td><td>0.9130</td><td>31.08</td><td>0.8950</td><td>30.41</td><td>0.9101</td><td>37.27</td><td>0.9740</td></tr><tr><td>EDSR</td><td>38.11</td><td>0.9602</td><td>33.92</td><td>0.9195</td><td>32.32</td><td>0.9013</td><td>32.93</td><td>0.9351</td><td>39.10</td><td>0.9773</td></tr><tr><td>RDN</td><td>32.24</td><td>0.9614</td><td>34.01</td><td>0.9212</td><td>32.34</td><td>0.9017</td><td>32.89</td><td>0.9353</td><td>39.18</td><td>0.9780</td></tr><tr><td>SRFBN</td><td>38.11</td><td>0.9609</td><td>33.82</td><td>0.9196</td><td>32.29</td><td>0.9010</td><td>32.62</td><td>0.9328</td><td>39.08</td><td>0.9779</td></tr><tr><td>SRGRN(ours)</td><td>38.25</td><td>0.9614</td><td>34.06</td><td>0.9214</td><td>32.37</td><td>0.9022</td><td>33.12</td><td>0.9367</td><td>39.31</td><td>0.9783</td></tr><tr><td>SRGRN+(ours)</td><td>38.31</td><td>0.9616</td><td>34.15</td><td>0.9220</td><td>32.43</td><td>0.9027</td><td>33.32</td><td>0.9382</td><td>39.51</td><td>0.9786</td></tr><tr><td>Bicubic</td><td rowspan="9"></td><td>30.39</td><td>0.8682</td><td>27.55</td><td>0.7742</td><td>27.21</td><td>0.7385</td><td>24.46</td><td>0.7349</td><td>26.95</td><td>0.8556</td></tr><tr><td>SRCNN</td><td>32.75</td><td>0.9090</td><td>29.30</td><td>0.8215</td><td>28.41</td><td>0.7863</td><td>26.24</td><td>0.7989</td><td>30.48</td><td>0.9117</td></tr><tr><td>DRRN</td><td>34.03</td><td>0.9244</td><td>29.96</td><td>0.8349</td><td>28.95</td><td>0.8004</td><td>27.53</td><td>0.8378</td><td>32.42</td><td>0.9359</td></tr><tr><td>LapSRN</td><td>33.82</td><td>0.9227</td><td>29.87</td><td>0.8320</td><td>28.82</td><td>0.7980</td><td>27.07</td><td>0.8280</td><td>32.21</td><td>0.9350</td></tr><tr><td>EDSR</td><td>34.65</td><td>0.9280</td><td>30.52</td><td>0.8462</td><td>29.25</td><td>0.8093</td><td>28.80</td><td>0.8653</td><td>34.17</td><td>0.9476</td></tr><tr><td>RDN</td><td>34.71</td><td>0.9296</td><td>30.57</td><td>0.8468</td><td>29.26</td><td>0.8093</td><td>28.80</td><td>0.8653</td><td>34.13</td><td>0.9484</td></tr><tr><td>SRFBN</td><td>34.70</td><td>0.9292</td><td>30.51</td><td>0.8461</td><td>29.24</td><td>0.8084</td><td>28.73</td><td>0.8641</td><td>34.18</td><td>0.9481</td></tr><tr><td>SRGRN(ours)</td><td>34.72 34.79</td><td>0.9297</td><td>30.60</td><td>0.8474</td><td>29.29</td><td>0.8102</td><td>28.95</td><td>0.8675</td><td>34.28</td><td>0.9491</td></tr><tr><td>SRGRN+(ours)</td><td></td><td>0.9301</td><td>30.69</td><td>0.8487</td><td>29.36</td><td>0.8114</td><td>29.11</td><td>0.8705</td><td>34.58</td><td>0.9506</td></tr><tr><td>Bicubic</td><td rowspan="9"></td><td>28.42</td><td>0.8104</td><td>26.00</td><td>0.7027</td><td>25.96</td><td>0.6675</td><td>23.14</td><td>0.6577</td><td>24.89</td><td>0.7866</td></tr><tr><td>SRCNN</td><td>30.48</td><td>0.8628</td><td>27.50</td><td>0.7513</td><td>26.90</td><td>0.7101</td><td>24.52</td><td>0.7221</td><td>27.58</td><td>0.8555</td></tr><tr><td>DRRN</td><td>31.68</td><td>0.8888</td><td>28.21</td><td>0.7721</td><td>27.38</td><td>0.7284</td><td>25.44</td><td>0.7638</td><td>29.18</td><td>0.8914</td></tr><tr><td>LapSRN</td><td>31.54</td><td>0.8850</td><td>28.19</td><td>0.7720</td><td>27.32</td><td>0.7270</td><td>25.21</td><td>0.7560</td><td>29.09</td><td>0.8900</td></tr><tr><td>EDSR</td><td>32.46</td><td>0.8968</td><td>28.80</td><td>0.7876</td><td>27.71</td><td>0.7420</td><td>26.64</td><td>0.8033</td><td>31.02</td><td>0.9148</td></tr><tr><td>RDN</td><td>32.47</td><td>0.8990</td><td>28.81</td><td>0.7871</td><td>27.72</td><td>0.7419</td><td>26.61</td><td>0.8028</td><td>31.00</td><td>0.9151</td></tr><tr><td>SRFBN</td><td>32.47</td><td>0.8983</td><td>28.81</td><td>0.7868</td><td>27.72</td><td>0.7409</td><td>26.60</td><td>0.8015</td><td>31.15</td><td>0.9160</td></tr><tr><td>SRGRN(ours)</td><td>32.56</td><td>0.8997</td><td>28.84</td><td>0.7880</td><td>27.75</td><td>0.7428</td><td>26.73</td><td>0.8053</td><td>31.13</td><td>0.9164</td></tr><tr><td>SRGRN+(ours)</td><td>32.68</td><td>0.9009</td><td>28.95</td><td>0.7903</td><td>27.83</td><td>0.7445</td><td>26.94</td><td>0.8106</td><td>31.52</td><td>0.9197</td></tr></table>
+
+# 4.4 RESULTS WITH BI DEGRADATION MODEL
+
+For BI degradation model, we compare our proposed SRGRN and ${ \mathrm { S R G R N } } +$ with other seven stateof-the-art image SR methods in quantitative terms. Following the previous works (Lim et al., 2017; Zhang et al., 2018b; Li et al., 2019), we also introduced a self-ensemble strategy to further improve the performance. We denote the self-ensemble method as ${ \mathrm { S R G R N } } +$ .
+
+A quantitative result for $\times 2 , \times 3$ , and $\times 4$ is shown in Table 2. We compare our models with other state-of-the-art methods on PSNR and SSIM. It can be seen that our proposed SRGRN outperforms other methods on all datasets without adding self-ensemble. After adopting self-ensemble, the performance further improves on the basis of SRGRN, and it achieved the best on all datasets. It is worth mentioning that SRFBN (Li et al., 2019) uses DIV2K $+$ Flickr2K as their training set, which employs more training images than us. Previous research has come to a conclusion that more data in training set leads to a better result. However, their results are still not comparable to ours. Although RDN (Zhang et al., 2018b) is a state-of-the-art method, our SRGRN can achieve better performance in all datasets through relational reasoning in upsampling and reconstruction parts. The quantitative results indicate that our GRUM and GRRB play a vital role in improving network performance.
+
+# 4.5 RESULTS WITH BD AND DN DEGRADATION MODELS
+
+To show the robustness of the model, we also show the SR results with BD degradation model and further introduce DN degradation model. We compare $3 \times \mathrm { S R }$ results with other seven state-of-theart image SR methods in quantitative terms. And We re-train SRCNN (Dong et al.) and VDSR (Kima et al., 2016) for BD and DN degradation model because of mismatched degradation model. For BD and DN, there is no doubt that reconstruction has become more difficult. As shown in Table 3 and Table 4, in the case of images with a lot of artifacts and noise, our SRGRN can get a excellent performance. This shows that SRGRN can effectively denoise and alleviate blurring artifacts. And when added to self-ensemble, SRGRN $^ +$ can achieve a better improvement.
+
+Table 3: Average PSNR/SSIM for scale factors $\times 3$ with BD degradation model. Best results are highlighted   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">scale</td><td colspan="2">Set5</td><td colspan="2">Set14</td><td colspan="2">BSDS100</td><td colspan="2">Urban100</td><td colspan="2">Manga109</td></tr><tr><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td rowspan="9"></td><td>28.78</td><td>0.8308</td><td>26.38</td><td>0.7271</td><td>26.33</td><td>0.6918</td><td>23.52</td><td>0.6862</td><td>25.46</td><td>0.8149</td></tr><tr><td>SRCNN</td><td>32.05</td><td>0.8944</td><td>28.80</td><td>0.8074</td><td>28.13</td><td>0.7736</td><td>25.70</td><td>0.7770</td><td>29.47</td><td>0.8924</td></tr><tr><td>VDSR</td><td>33.25</td><td>0.9150</td><td>29.46</td><td>0.8244</td><td>28.57</td><td>0.7893</td><td>26.61</td><td>0.8136</td><td>31.06</td><td>0.9234</td></tr><tr><td>IRCNN_G</td><td>33.38</td><td>0.9182</td><td>29.63</td><td>0.8281</td><td>28.65</td><td>0.7922</td><td>26.77</td><td>0.8154</td><td>31.15</td><td>0.9245</td></tr><tr><td>IRCNN_C</td><td>×3 33.17</td><td>0.9157</td><td>29.55</td><td>0.8271</td><td>28.49</td><td>0.7886</td><td>26.47</td><td>0.8081</td><td>31.13</td><td>0.9236</td></tr><tr><td>SRMDNF</td><td>34.09</td><td>0.9242</td><td>30.11</td><td>0.8364</td><td>28.98</td><td>0.8009</td><td>27.50</td><td>0.8370</td><td>32.97</td><td>0.9391</td></tr><tr><td>RDN</td><td>34.57</td><td>0.9280</td><td>30.53</td><td>0.8447</td><td>29.23</td><td>0.8079</td><td>28.46</td><td>0.8581</td><td>33.97</td><td>0.9465</td></tr><tr><td>SRGRN(ours)</td><td>34.66</td><td>0.9286</td><td>30.60</td><td>0.8460</td><td>29.27 29.35</td><td>0.8090</td><td>28.71</td><td>0.8633</td><td>34.27</td><td>0.9480</td></tr><tr><td>SRGRN+(ours)</td><td>34.78</td><td>0.9295</td><td>30.71</td><td>0.8476</td><td></td><td>0.8104</td><td>28.96</td><td>0.8673</td><td>34.65</td><td>0.9498</td></tr></table>
+
+Table 4: Average PSNR/SSIM for scale factors $\times 3$ with DN degradation model. Best results are highlighted   
+
+<table><tr><td rowspan="2">Method</td><td rowspan="2">scale</td><td colspan="2">Set5</td><td colspan="2">Set14</td><td colspan="2">BSDS100</td><td colspan="2">Urban100</td><td colspan="2">Manga109</td></tr><tr><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td rowspan="9"></td><td>24.01</td><td>0.5369</td><td>22.87</td><td>0.4724</td><td>22.92</td><td>0.4449</td><td>21.63</td><td>0.4687</td><td>23.01</td><td>0.5381</td></tr><tr><td>SRCNN</td><td>25.01</td><td>0.6950</td><td>23.78</td><td>0.5898</td><td>23.76</td><td>0.5538</td><td>21.90</td><td>0.5737</td><td>23.75</td><td>0.7148</td></tr><tr><td>VDSR</td><td>25.20</td><td>0.7183</td><td>24.00</td><td>0.6112</td><td>24.00</td><td>0.5749</td><td>22.22</td><td>0.6096</td><td>24.20</td><td>0.7525</td></tr><tr><td>IRCNN_G</td><td>25.70</td><td>0.7379</td><td>24.45</td><td>0.6305</td><td>24.28</td><td>0.5900</td><td>22.90</td><td>0.6429</td><td>24.88</td><td>0.7765</td></tr><tr><td>IRCNN_C</td><td>27.48</td><td>0.7925</td><td>25.92</td><td>0.6932</td><td>25.55</td><td>0.6481</td><td>23.93</td><td>23.93</td><td>26.07</td><td>0.8253</td></tr><tr><td>RDN</td><td>28.46</td><td>0.8151</td><td>26.60</td><td>0.7101</td><td>25.93</td><td>0.6573</td><td>24.92</td><td>0.7362</td><td>28.00</td><td>0.8590</td></tr><tr><td>SRFBN</td><td>28.53</td><td>0.8182</td><td>26.60</td><td>0.7144</td><td>25.95</td><td>0.6625</td><td>24.99</td><td>0.7424</td><td>28.02</td><td>0.8618</td></tr><tr><td>SRGRN(ours)</td><td>28.62 28.67</td><td>0.8195</td><td>26.66 26.73</td><td>0.7151</td><td>25.99 26.07</td><td>0.6632</td><td>25.14</td><td>0.7462</td><td>28.11</td><td>0.8642</td></tr><tr><td>SRGRN+(ours)</td><td></td><td>0.8206</td><td></td><td>0.7168</td><td></td><td>0.6645</td><td>25.31</td><td>0.7496</td><td>28.31</td><td>0.8674</td></tr></table>
+
+# 4.6 SUPER-RESOLUTION ON REAL-WORLD IMAGES
+
+To prove that our SRGRN can be widely used in the real world and performs robustly, we also conduct SR experiments on representative real-world images. We reconstruct some low resolution images in the real world that lack a lot of high frequency information. Moreover, in this case, the original HR images are not available and the degradation model is unknown either. Experiments show our SRGRN can recover finer and more faithful real-world images than other state-of-the-art methods under this bad condition. This further reflects the superiority of relation reasoning.
+
+# 5 CONCLUSION
+
+In this paper, inspired by the process of reconstructing images from the human visual system, we propose an super-resolution global reasoning network (SRGRN) for image SR, which aims at completing the reconstruction of SR images through global reasoning. We mainly propose global reasoning upsampling module (GRUM) and global reasoning reconstruction block (GRRB) as the core of the network. The GRUM can give the upsampling module the ability to perform relational reasoning in a global scope, which allows this process to overcome the limitations of the receptive field and recover more faithful details by analyzing more contextual information. The GRRB also enables the reconstruction block to make full use of the interaction between the regions and pixels to reconstruct SR images. We exploit SRGRN not only to handle low resolution images that are corrupted by three degradation model, but also to handle real-world images. Extensive benchmark evaluations demonstrate the importance of GRUM and GRRB. It also indicates that our SRGRN achieves superiority over state-of-the-art methods through global reasoning.
+
+Acknowledgements. This research is supported by National Key R&D Program of China under grant 2018YFC0831503
+
+# REFERENCES
+
+Eirikur Agustsson and Radu Timofte. Ntire 2017 challenge on single image super-resolution: Dataset and study. 2017.
+
+Namhyuk Ahn, Byungkon Kang, and Kyung-Ah Sohn. Fast, accurate, and lightweight superresolution with cascading residual network.
+
+Marco Bevilacqua, Aline Roumy, Christine Guillemot, and Marie-Line Alberi Morel. Lowcomplexity single-image super-resolution based on nonnegative neighbor embedding. 2012.
+
+Logan Chariker, Robert Shapley, and Lai-Sang Young. Orientation selectivity from very sparse lgn inputs in a comprehensive model of macaque v1 cortex. 2016.
+
+Logan Chariker, Robert Shapley, and Lai-Sang Young. Rhythm and synchrony in a cortical network model. 2018.
+
+Yunpeng Chen, Marcus Rohrbach, Zhicheng Yan, Shuicheng Yan, Jiashi Feng, and Yannis Kalantidis. Graph-based global reasoning networks. 2018.
+
+Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Learning a deep convolutional network for image super-resolution.
+
+Chao Dong, Chen Change Loy, and Xiaoou Tang. Accelerating the super-resolution convolutional neural network. 2016.
+
+Muhammad Haris, Greg Shakhnarovich, and Norimichi Ukita. Deep back projection networks for super-resolution. 2018.
+
+Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. 2017.
+
+Jia-Bin Huang, Abhishek Singh, and Narendra Ahuja. Single image super-resolution from transformed self-exemplars. 2015.
+
+Jiwon Kim, Jung Kwon Lee, and Kyoung Mu Lee. Deeply-recursive convolutional network for image super-resolution. 2016.
+
+Jiwon Kima, Jung Kwon Lee, and Kyoung Mu Lee. Accurate image super-resolution using very deep convolutional networks. 2016.
+
+Wei-Sheng Lai, Jia-Bin Huang, Narendra Ahuja, and Ming-Hsuan Yang. Deep laplacian pyramid networks for fast and accurate super-resolution. 2017.
+
+Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro t’ Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photorealistic single image super-resolution using a generative adversarial network. 2017.
+
+Juncheng Li, Faming Fang, Kangfu Mei, and Guixu Zhang. Multi-scale residual network for image super-resolution. 2018.
+
+Zhen Li, Jinglei Yang, Zheng Liu, Xiaomin Yang, Gwanggil Jeon, and Wei Wu. Feedback network for image super-resolution. 2019.
+
+Bee Lim, Sanghyun Son, Heewon Kim, Seungjun Nah, and Kyoung Mu Lee. Enhanced deep residual networks for single image super-resolution. 2017.
+
+Yong Liu, Ruiping Wang, Shiguang Shan, and Xilin Chen. Structure inference net: Object detection using scene-level context and instance-level relationships. 2018.
+
+Andrew L. Maas, Awni Y. Hannun, and Andrew Y. Ng. Rectifier nonlinearities improve neural network acoustic models. 2013.
+
+David Martin, Charless Fowlkes, Doron Tal, and Jitendra Malik. A database of human segmented natural images and its application to evaluating segmentation algorithms and measuring ecological statistics. 2001.
+
+Tomer Peleg and Michael Elad. A statistical prediction model based on sparse representations for single image super-resolution. 2014.
+
+Adam Santoro, David Raposo, David G.T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. 2017.
+
+Samuel Schulter, Christian Leistner, and Horst Bischof. Fast and accurate image upscaling with super-resolution forests. 2015.
+
+Wenzhe Shi, Jose Caballero, Ferenc Huszár, Johannes Totz, Andrew P. Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. 2016.
+
+Ying Tai, Jian Yang, and Xiaoming Liu. Image super-resolution via deep recursive residual network. 2017.
+
+Radu Timofte, Vincent De Smet, and Luc Van Gool. Anchored neighborhood regression for fast example-based super-resolution. 2013.
+
+Radu Timofte, Vincent De Smet, and Luc Van Gool. $\mathbf { A } +$ : Adjusted anchored neighborhood regression for fast super-resolution. 2014.
+
+Tong Tong, Gen Li, Xiejie Liu, and Qinquan Gao. Image super-resolution using dense skip connections. 2017.
+
+Xintao Wang, Ke Y, Shixiang W, Jinjin Gu, Yihao Liu, Chao Dong, Chen Change Loy, Yu Qiao, and Xiaoou Tang. Esrgan: Enhanced super-resolution generative adversarial networks. 2018.
+
+Zhou Wang, Alan Conrad Bovik, Hamid Rahim Sheikh, and Eero P. Simoncelli. Image quality assessment: from error visibility to structural similarity. 2004.
+
+Y.Matsui, K.Ito, Y.Aramaki, A.Fujimoto, T.Ogawa, T.Ya masaki, and K. Aizawa. Sketch-based manga retrieval using manga109 dataset. 2017.
+
+Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. 2014.
+
+Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor, and Rob Fergus. Deconvolutional networks. 2010.
+
+Roman Zeyde, Michael Elad, and Matan Protter. On single image scale-up using sparserepresentations. 2010.
+
+Kai Zhang, Wangmeng Zuo, and Lei Zhang. Learning a single convolutional super-resolution network for multiple degradations. 2018a.
+
+Kaibing Zhang, Xinbo Gao, Dacheng Tao, and . Xuelong Li. Single image super-resolution with non-local means and steering kernel regression. 2012.
+
+Lei Zhang and Xiaolin Wu. An edge-guided image interpolation algorithm via directional filtering and data fusion. 2006.
+
+Yulun Zhang, Yapeng Tian, Yu Kong, Bineng Zhong, and Yun Fu. Residual dense network for image super-resolution. 2018b.
+
+# A APPENDIX
+
+# A.1 VISUAL RESULT
+
+Visual comparison with BI degradtion model. As shown in Figure 5, we show a visual comparison on $4 \times$ SR. For image "img_078" from Urban100, we observe that most methods, even RDN and SRFBN, cannot recover these lattices and suffer from extremely severe blurring artifacts. Only our SRGRN can alleviate these blurring artifacts, recovers sharper and clearer edges and finer texture. For image "MukoukizuNoChonbo" from Manga109, There are heavy blurrings artifacts in all comparison methods, and the outline of some letters are broken. However, our proposed SRGRN can accurately recover these outlines, more faithful to the ground truth. The above comparison results are mainly due to the fact that SRGRN can enable upsampling and reconstruction modules to utilize more contextual information through relation reasoning.
+
+Visual comparison with BD and DN degradtion model. In Figure 6, we show the comparison of SRGRN with other models in visual results. For image "img_ $. 0 1 4 "$ , we use bicubic upsampling to recover these images whose HR images are blurred with a Gaussian kernel before bicubic downsampling, then we obtain SR images with a lot of noticeable blurring artifacts. We have also observed that most methods, including RDN and SRFBN, do not clearly recover the lines around the window. Only our SRGRN can suppress blurring artifacts and recover these clear enough lines close to the ground truth by relation reasoning. For image "img $\underline { { 0 0 2 } } "$ , a large amount of noise corrupt the LR image and make it loss some detail. It can be seen that when using bicubic for upsampling, the obtained image not only has a large number of blurring artifacts but also a large amount of noise. However, we find that our SRGRN has great potential for removing noise efficiently and recover more detail. This fully demonstrates the effectiveness and robustness of our SRGRN for BD and DN degradation models.
+
+Visual comparison on Real-World Images. In figure 7, the resolution of these images is so small that there is a lot of high frequency information missing from them. Moreover, in this case, the original HR images are not available and the degradation model is unknown either. For image "window"(with $2 0 0 \times 1 6 0$ pixels), only our SRGRN is able to recover sharper window edges and produce clearer SR image. For image "flower"(with $2 5 6 \times 2 0 0$ pixels), most other methods recover images whose upper left corner produces the edge of the pistil that looks unreal. And their edges of the petals in the whole image are very blurry. Our SRGRN can recovers sharper edges and finer details than other state-of-the-art methods. The above analysis indicate our model perform robustly unknown degradation models. This further reflects the superiority of relation reasoning.
+
+![](images/c1032250f11f2acd645ef1c518eaa984b8c9f85802e4332b84c97bd964adaf3b.jpg)  
+Figure 5: Visual comparison for $4 \times$ SR with BI model on "img_078" from Urban100 and "MukoukizuNoChonbo" from Manga109.
+
+![](images/e7ddcced9abf43c15cedfa2f4e7b02b00e080ce04b90f6d9422e29e100756858.jpg)  
+Figure 6: Visual comparison for $3 \times$ SR with BD model on "img_014" from Urban100 and for $3 \times$ SR with DN model on "img_002" from Urban100
+
+![](images/a0e9bf16cb54dd571ac899ba5f43da15c124d477eb5675bb5770a8726e7072aa.jpg)  
+Figure 7: Visual comparison for $\mathbf { 4 } \times \mathbf { S R }$ on real-world images. The two images show "flowers" and "window" respectively.

parse/train/S1gE6TEYDB/S1gE6TEYDB_content_list.json

@@ -0,0 +1,1673 @@
+[
+    {
+        "type": "text",
+        "text": "GLOBAL REASONING NETWORK FOR IMAGE SUPERRESOLUTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            826,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recent image super-resolution(SR) studies leverage very deep convolutional neural networks and the rich hierarchical features they offered, which leads to better reconstruction performance than conventional methods. However, the small receptive fields in the up-sampling and reconstruction process of those models stop them to take full advantage of global contextual information. This causes problems for further performance improvement. In this paper, inspired by image reconstruction principles of human visual system, we propose an image super-resolution global reasoning network (SRGRN) to effectively learn the correlations between different regions of an image, through global reasoning. Specifically, we propose global reasoning up-sampling module (GRUM) and global reasoning reconstruction block (GRRB). They construct a graph model to perform relation reasoning on regions of low resolution (LR) images.They aim to reason the interactions between different regions in the up-sampling and reconstruction process and thus leverage more contextual information to generate accurate details. Our proposed SRGRN are more robust and can handle low resolution images that are corrupted by multiple types of degradation. Extensive experiments on different benchmark data-sets show that our model outperforms other state-of-the-art methods. Also our model is lightweight and consumes less computing power, which makes it very suitable for real life deployment. ",
+        "bbox": [
+            233,
+            265,
+            766,
+            530
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            545,
+            336,
+            560
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Image Super-Resolution (SR) aims to reconstruct an accurate high-resolution (HR) image given its low-resolution (LR) counterpart. It is a typical ill-posed problem, since the LR to HR mapping is highly uncertain. In order to solve this problem, a large number of methods have been proposed, including interpolation-based (Zhang & Wu., 2006), reconstruction-based(Zhang et al., 2012), and learning-based methods (Timofte et al., 2013; 2014; Peleg & Elad., 2014; Schulter et al., 2015; Dong et al.; Huang et al., 2015; Tai et al., 2017; Tong et al., 2017; Zhang et al., 2018a; Dong et al., 2016). ",
+        "bbox": [
+            174,
+            575,
+            825,
+            660
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In recent years, deep learning based methods have achieved outstanding performance in superresolution reconstruction. Some effective residual or dense blocks (Huang et al., 2017; Zhang et al., 2018b; Wang et al., 2018; Lim et al., 2017; Ledig et al., 2017; Ahn et al.; Li et al., 2018) have been proposed to make the network wider and deeper and achieved better results. However, they only pay close attention to improving the feature extraction module, ignoring that the upsampling process with smaller receptive fields does not make full use of those extracted features. Small convolution receptive field means that the upsampling process can only perform super-resolution reconstruction based on local feature relationships in LR. As we all know, different features interact with each other, and features which are in different regions have corresponding effects on upsampling and reconstruction of a certain region. That is to say that a lot of information is lost in the process of upsampling and reconstruction due to the limitation of the receptive field, although the network extracts a large number of hierarchical features which are from low frequency to high frequency. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            833
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Chariker et al. (2016; 2018) show that the brain generates the images we see based on a small amount of information observed by the human eye, ranther than acquiring the complete data from the point-by-point scan of the retina. This process of generating an image is similar to a SR process. According to their thought, we add global information in SR reconstruction and propose to use relational reasoning to implement the process that the human visual system reconstructs images with observed global information. In general, extracting global information requires a large receptive field. A large convolution receptive field usually requires stacking a large number of convolutional layers, but this method does not work in the upsampling and reconstruction process. Because this will produce a huge number of parameters. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Based on the above analysis, we propose an image super-resolution global reasoning network (SRGRN) which introduces the global reasoning mechanism to the upsampling module and the reconstruction layer. The model can capture the relationship between disjoint features of the image with a small respective field, thereby fully exploits global information as a reference for upsampling and reconstruction. We mainly propose global reasoning upsampling module (GRUM) and global reasoning reconstruction block (GRRB) as the core structure of the network. GRUM and GRRB first convert the LR feature map into $N$ nodes, each of which not only represents a feature region in the LR image, but also contains the influence of pixels in other regions on this feature. Then they learn the relationship between the nodes and fuse the information of each node in a global scope. After that, GRUM learns the relationship between the channels in each node and amplifies the number of channels for the upsampling process. And then they convert $N$ nodes into pixels with global reasoning information. Finally, GRUM and GRRB complete the upsampling and reconstruction process respectively. ",
+        "bbox": [
+            174,
+            154,
+            826,
+            333
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In general, our work mainly has the following three contributions: ",
+        "bbox": [
+            173,
+            340,
+            606,
+            354
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We propose an image super-resolution global reasoning network (SRGRN) which draws on the idea of image reconstruction principles of human visual system. We mainly focus on the upsampling module and the reconstruction module. The model reconstructs SR images based on relational reasoning in a global scope.   \n• We propose a global reasoning upsampling module (GRUM) and global reasoning reconstruction block (GRRB), which construct a graph model to implement the relational reasoning among the feature regions in an image via 1D and 2D convolution, and finally adds the information obtained by global reasoning to each pixel. It can provide more contextual information to help generate more accurate details.   \n• Our proposed GRUM and GRRB are lightweight, which makes it suitable for real life deployment. More importantly, GRUM and GRRB balance the number of parameters and the reconstruction performance well. They can be easily inserted into other models. ",
+        "bbox": [
+            215,
+            366,
+            825,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            571,
+            354,
+            588
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Deep CNN for SR and upsampling methods. Deep learning has achieved excellent performance in image super-resolution tasks. For the first time, Dong et al. applied convolutional neural networks to image SR. After this, Kim et al. proposed VDSR (Kima et al., 2016) and DRCN (Kim et al., 2016) which introduced residual learning to make the network depth reach 20 layers achieved significant improvement. And then more and more researchers are starting to pay attention to the improvement of the network feature extraction part. Lim et al. (2017) proposed EDSR and MDSR, which introduce residual scaling and remove unnecessary modules from the residual block. Concerned that the previous models only adopt the feather of the last CNN, Zhang et al. (2018b) proposed residual dense network to make full use of hierarchical features from each Conv layer. The above and most of the subsequent networks implement the upsampling based on either transposed convolution (Zeiler et al., 2010; Zeiler & Fergus., 2014) or sub-pixel convolution (Shi et al., 2016). Although these models have achieved good results, there exists a problem that these upsampling methods have only a small receptive field. This means that upsampling can only take advantage of contextual information within a small area. ",
+        "bbox": [
+            174,
+            604,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, researchers propose some new super-resolution upsampling process. LapSRN (Lai et al., 2017) allows low-resolution images to be directly input into the network for step-by-step amplification. Haris et al. (2018) exploit iterative up-and-down sampling layers and propose DBPN. Li et al. (2019) further explore the application of feedback mechanism (weight sharing) in SR and propose the SRFBN. These models have achieved a better reconstruction performance. However, the Conv layers in these upsampling modules still have only a small receptive field. ",
+        "bbox": [
+            174,
+            805,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Global reasoning machansim. Recently, graph-based deep learning methods have begun to be widely used to solve relation reasoning. Santoro et al. propose Relation Networks (RN) (Santoro et al., 2017) to solve problems that depend on relational reasoning. Liu et al. (2018) propose SIN, which implement a object detection using a graph model for structure inference. Furthermore, Chen et al. (2018) model a Global Reasoning unit that consists of five convolutions for image classification, semantic segmentation and video action recognition task. Considering that the human visual system generates images based on the observed global information is also a reasoning process. Moreover, correlation between feature regions can be obtained through relational reasoning, which makes each pixel in the generated SR image jointly determined by the information in a global scope. Therefore, we propose a global reasoning network for SR. We will detail our SRGRN in next section. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            826,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            219,
+            362,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "According to Chariker et al. (2016; 2018), there is only little information transmitted from the retina to the visual cortex, and then the brain will reconstruct the real-world images based on the information received. We regard it as a reasoning process in a global scope. For image SR, the upsampling module constructs SR images base on features in LR images, which is substantially similar to detecting the category of each pixel of a SR image and generating these pixels based on contextual information of corresponding LR image. Due to the limitation of the convolution receptive field, only a small amount of contextual information can be utilized to generate HR images in most other models. This leads that many details in the HR image are not fine. Similarly, the above problem also exists in the reconstruction process. To solve these problems, we simulate the reasoning process that exists in human visual system, and then propose SRGRN to make full use of the contextual information to recover accurate details, which is achieved by constructing graph model and reasoning the relationship between these regions in an image. ",
+        "bbox": [
+            173,
+            251,
+            826,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b8a9e67a715c5cd8443b361a1c0e9d5fd46bb02632651a48a971d3280e16e07.jpg",
+        "image_caption": [
+            "Figure 1: Super-resolution global reasoning network (SRGRN) architecture "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            259,
+            421,
+            735,
+            517
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            544,
+            326,
+            558
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 1, our SRGRN includes feature extraction part, global reasoning upsample module(GRUM) and global reasoning reconstruction block(GRRB). Let’s denote $I _ { L R }$ and $I _ { S R }$ as the input and output of SRGRN. The feature extraction part can use the relevant architecture of most other models. Here we introduce the feature extraction part of the RDN (Zhang et al., 2018b) as an example. ",
+        "bbox": [
+            173,
+            569,
+            825,
+            638
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/200f5a70cc32eab561147c74786f45ba34b00330d11cc3c78eb478d3cf302f41.jpg",
+        "text": "$$\nF _ { L } = H _ { F E X } ( I _ { L R } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            433,
+            638,
+            565,
+            655
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { F E X } ( \\cdot )$ denotes a series of operations of feature extraction part. ",
+        "bbox": [
+            173,
+            656,
+            645,
+            671
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "As with the previous work (Lim et al., 2017), the number of GRUM depends on the scaling factor, The GRUM receives $F _ { L }$ as input. $F _ { S }$ represents the output of the GRUM. GRUM can be expressed by the following mathematical formula: ",
+        "bbox": [
+            173,
+            676,
+            821,
+            718
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/21ed51b63c2dd3feabc9c320383d6cdf819cf140f492ab384dde6ae312c149e6.jpg",
+        "text": "$$\nF _ { S } = H _ { G R U M } ( F _ { L } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            429,
+            723,
+            568,
+            739
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { G R U M } ( \\cdot )$ denotes a series of operations of GRUM. More details about GRUM will be given in Section 3.2. ",
+        "bbox": [
+            171,
+            742,
+            825,
+            770
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We further conduct global reasoning reconstruction block(GRRB) to utilize the global contextual information to generate the output image. GRRB can be expressed by the following mathematical formula: ",
+        "bbox": [
+            176,
+            776,
+            825,
+            818
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8f3d8e7202167ee692412963ebab2ac318c877e412769c3d8b8ad746d5912b80.jpg",
+        "text": "$$\nI _ { S R } = H _ { G R R B } ( F _ { S } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            818,
+            568,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { G R R B } ( \\cdot )$ denotes a series of operations of GRRB. More details about GRRB will be given in Section 3.3. After the above operations, we get the corresponding SR image. ",
+        "bbox": [
+            176,
+            835,
+            826,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.2 GLOBAL REASONING UPSAMPLING MODULE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            522,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we present details about our proposed global reasoning upsample module(GRUM) in Figure 2. In order to help achieve relation reasoning, we map each image to a graph model ",
+        "bbox": [
+            174,
+            895,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/8d146d61712d5799dbbf982bbb8c70d1dcd64de9d09447e116f6d5a2013ee935.jpg",
+        "image_caption": [
+            "Figure 2: Global reasoning upsampling module (GRUM) architecture "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            241,
+            104,
+            756,
+            214
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$G = ( V , E , u )$ , where nodes in graph represent different regions in the image, E represents the relationship weight between the different regions, stored in the adjacency matrix of the graph, and u is the global information of the entire image. ",
+        "bbox": [
+            174,
+            247,
+            825,
+            289
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We first need a function to construct $N$ nodes in the oriented graph, each of which represents a region in the image. In GRUM, we obtain relationship weights between these pixels through a 2D $1 \\times 1$ convolution, and then convert the input $F _ { L }$ into $N$ nodes via element-wise product. The benefits of this approach are mainly reflected in the following aspects: (1) It can not only aggregates a feature region of the input $F _ { L }$ into a node, but also dig out the influence of other pixels in the image on this region. This is equivalent to adding global guidance of the image to each node. (2) Using convolution means that these relationship weights are trainable. This process can be expressed by the following mathematical formula: ",
+        "bbox": [
+            173,
+            295,
+            825,
+            407
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e2c1e6274afc038ef25a103b7d56d3241886f545eb4c14b5adfc592b4d5b13cc.jpg",
+        "text": "$$\nW _ { n } = V _ { d } ( C o n v ( F _ { L } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            421,
+            412,
+            575,
+            430
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/010c73a49fe230fb15a6d9f4aa2121f97fc48bc99483245cc066d74f6e143a8b.jpg",
+        "text": "$$\nY _ { W } = W _ { n } \\cdot ( V _ { d } ( F _ { L } ) ) ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            418,
+            434,
+            578,
+            453
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { L } \\in \\mathbb { R } ^ { C \\times H \\times W }$ denotes the input tensor, $V _ { d } ( \\cdot )$ denotes the operation of converting the vector shape from $N \\times H \\times W$ to $N { \\times } H W$ , $\\bar { W } _ { n } \\in \\mathbb { R } ^ { N \\times H W }$ denotes relationship weights and $\\boldsymbol { Y } _ { W } ^ { \\mathbf { - } } \\in \\mathbb { R } ^ { N \\times C }$ refers to $N$ nodes with C channels. ",
+        "bbox": [
+            174,
+            455,
+            825,
+            497
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "After that, we use the 1D Conv - Leaky ReLu - 1D Conv (CLC) structure to implement reasoning and interaction between $N$ nodes in the graph. The parameters in CLC refer to the adjacency matrix of the weighted oriented complete graph, which store the correlations between the nodes. CLC can learn and reason the complex nonlinear relationship between nodes better than only one 1D Conv. We use the following formula to describe the reasoning process between nodes: ",
+        "bbox": [
+            173,
+            503,
+            825,
+            575
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/060c3bb7e45c2d751880f4c3bdf7e9fe524012ce36b9af9253137473cf8dafb0.jpg",
+        "text": "$$\nY _ { N } = C o n v ( L R e l u ( C o n v ( Y _ { W } ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            580,
+            616,
+            597
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $C o n v ( \\cdot )$ and $L R e l u ( \\cdot )$ denote 1D convolution along node-wise and Leaky ReLU (Maas et al., 2013) operation respectively. ",
+        "bbox": [
+            171,
+            602,
+            825,
+            631
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "And then we use the bottleneck to achieve channel amplification. The bottleneck receives $Y _ { N } \\in \\cal { Y }$ $\\mathbb { R } ^ { N \\times C }$ as input and redistributes these channels by modeling the relationship between the channels of each node, amplifying the number of channel to $C \\times r ^ { 2 }$ , where $\\mathbf { r }$ is the upscaling factor. ",
+        "bbox": [
+            173,
+            637,
+            825,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The first convolution in bottleneck makes channel C drop to $\\bar { C } = C / \\alpha$ , where $\\alpha$ represents reduction ratio. Then the second convolution makes the channel dimension $\\bar { C }$ grow to $C \\times \\bar { r } ^ { 2 }$ . The bottleneck not only fits the complex relationships between channels better and redistributes channels more accurately, but also greatly reduces the number of parameters compared to the method of utilizing a single convolution. We use the following formula to describe channel amplification: ",
+        "bbox": [
+            173,
+            685,
+            825,
+            757
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7eaf56a77d3fc69900fdaa822c597a0e623a2562d34c73830848e52b1804180b.jpg",
+        "text": "$$\nY _ { N C } = C o n v ( L R e l u ( C o n v ( ( Y _ { N } ) ^ { T } ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            366,
+            762,
+            630,
+            781
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $Y _ { N C } \\in \\mathbb { R } ^ { r ^ { 2 } C \\times N }$ refers to the output tensor. ",
+        "bbox": [
+            173,
+            787,
+            503,
+            804
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to expand the resolution by pixelshuffle like ESPCN (Shi et al., 2016), we need to retransform the $N$ nodes $( r ^ { 2 } C \\times N )$ which have implemented the relational reasoning into a space whose shape is $C \\times H \\times W$ . As above, we still learn a function to get a weight matrix whose shape is $N \\times H W$ through a $1 \\times 1$ 2D convolution, and then normalize the weight matrix along the column with softmax. Finally, $Y _ { r C }$ and $W _ { P }$ can be obtained through: ",
+        "bbox": [
+            173,
+            810,
+            825,
+            881
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3cffdffe1139fef394c349ae4480c19b6837147dd57aa86e2f64250c2f97fcc1.jpg",
+        "text": "$$\nW _ { P } = S o f t m a x ( V _ { d } ( C o n v ( F _ { L } ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            886,
+            614,
+            904
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cdce54b57079132f16082c8f8e556fe07c1b26998b0f2ad8704757d28ed6978e.jpg",
+        "text": "$$\nY _ { r C } = V _ { u } ( Y _ { N C } W _ { P } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            428,
+            909,
+            570,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $V _ { u } ( \\cdot )$ denotes the operation of reshaping $N \\times H W$ to $N \\times H \\times W$ . $Y _ { r C } \\in \\mathbb { R } ^ { r ^ { 2 } C \\times H \\times W }$ is a ·feature map where each pixel is associated with $N$ ×nodes. $W _ { P } \\in \\mathbb { R } ^ { N \\times H W }$ ∈is the normalized weight matrix. The value of these weights ranges from 0 to 1. This means that the reconstruction of each pixel is affected by $N$ nodes to varying degrees. Each pixel in the feature map contains information which is generated by global reasoning. ",
+        "bbox": [
+            173,
+            102,
+            825,
+            174
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After pixelshuffle, the output is multiplied by a parameter $\\gamma _ { 1 }$ and added to the upsampling result without global reasoning. The initial value of $\\gamma _ { 1 }$ is set to 0. As the global reasoning module trains, the network will gradually learn to assign values to the $\\gamma _ { 1 }$ , thereby fully exploiting global reasoning. This process can be expressed by the following formula: ",
+        "bbox": [
+            173,
+            180,
+            825,
+            236
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2b3b289df1094e202ba2f1a771a17ad689f2c3412725a6c59e0a3cfb35406262.jpg",
+        "text": "$$\nY _ { S } = H _ { P S } ( Y _ { r C } ) \\cdot \\gamma _ { 1 } + H _ { U P } ( F _ { L } ) \\cdot ( 1 - \\gamma _ { 1 } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            348,
+            239,
+            650,
+            257
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { P S } ( \\cdot )$ denotes the operations of pixel shuffle and $H _ { U P } ( \\cdot )$ denotes the operations of subpixel convolution. ",
+        "bbox": [
+            173,
+            261,
+            826,
+            289
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Finally, $F _ { S }$ can be obtained by: ",
+        "bbox": [
+            173,
+            296,
+            380,
+            310
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f29d7043cbf9e3260400eb102ffa5e1058c1f92ad024c85a95d0f402fffe80eb.jpg",
+        "text": "$$\nF _ { S } = C o n v ( Y _ { S } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            309,
+            558,
+            325
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/6f54f4278a32a0e4c886e29bc1188ed4c638443e18ddbc339d7009f15e6fd534.jpg",
+        "image_caption": [
+            "Figure 3: Global reasoning reconstruction block (GRRB) architecture "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            254,
+            333,
+            740,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 GLOBAL REASONING RECONSTRUCTION BLOCK",
+        "text_level": 1,
+        "bbox": [
+            174,
+            467,
+            544,
+            479
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "As shown in Figure 3, the specific details are similar to GRUM. We also construct a graph model for reconstruction block. ",
+        "bbox": [
+            171,
+            491,
+            825,
+            520
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In GRRB, we first obtain the relationship weights $W _ { R N } \\in \\mathbb { R } ^ { N \\times r H r W }$ between pixels of $F _ { S }$ by 2D 1x1 convolution, and then aggregate the regions in $F _ { S }$ into $N$ nodes by element-wise product. The output of this process $\\boldsymbol { Y } _ { R W } \\in \\mathbb { R } ^ { \\boldsymbol { N } \\times \\boldsymbol { C } }$ can be formulated as: ",
+        "bbox": [
+            174,
+            525,
+            825,
+            569
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fd185abfa4816742a3a65b10a591a85b460775c1a43c7b3f50bc1cab52a24c04.jpg",
+        "text": "$$\n\\begin{array} { r } { Y _ { R W } = W _ { R N } \\cdot ( V _ { d } ( F _ { S } ) ) ^ { T } = V _ { d } ( C o n v ( F _ { S } ) ) \\cdot ( V _ { d } ( F _ { S } ) ) ^ { T } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            303,
+            573,
+            692,
+            592
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "After that, we use CLC to achieve the relationship reasoning between nodes. Then we exploit the weight matrix $W _ { R P } \\in \\mathbb { R } ^ { N \\times r H r W } = \\acute { S o f t m a x } ( V _ { d } ( C o n \\bar { v } ( F _ { S } ) ) )$ obtained by learning to redistribute the information of $N$ nodes to the pixels. The output of this process $Y _ { R r C } \\mathbf { \\dot { \\in } } \\mathbb { R } ^ { C \\times r \\mathbf { \\widecheck { H } } \\times r W }$ can be obtained by: ",
+        "bbox": [
+            174,
+            594,
+            825,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f75b9bfac778a067689c78ebe71b69e074501615fcf826964fb8254d954cf1fc.jpg",
+        "text": "$$\nY _ { R r C } = V _ { u } ( ( F _ { C L C } ( Y _ { R W } ) ) ^ { T } \\cdot W _ { R P } ) = V _ { u } ( ( F _ { C L C } ( Y _ { R W } ) ) ^ { T } \\cdot S o f t m a x ( V _ { d } ( C o n v ( F _ { S } ) ) ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            181,
+            655,
+            787,
+            674
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $F _ { C L C }$ refers to the operations of CLC. In addition, we apply the idea of residual connection in GRRB, which multiplys the information generated via global reasoning by a parameter $\\gamma$ and then add it to the input feature map. The output is given by: ",
+        "bbox": [
+            174,
+            676,
+            826,
+            719
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8fbd72de422aaf9593640cf9299284044e1f231f586f6d56c9e8f100b5b77597.jpg",
+        "text": "$$\nY _ { R S } = \\gamma \\cdot Y _ { R r C } + F _ { S }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            423,
+            723,
+            575,
+            739
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The initial value of $\\gamma$ is set to 0. As the training progresses, the network assigns more weight to $\\gamma$ . Finally, we input the feature map with global reasoning into the two Convs for reconstruction. We can get the final output through: ",
+        "bbox": [
+            174,
+            743,
+            826,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7bb0e828b91ef73edbd7989910b3e11a2bb129c0295fbf16b63727176c9d1ebe.jpg",
+        "text": "$$\nI _ { S R } = H _ { R L } ( Y _ { R S } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            784,
+            562,
+            801
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { R L } ( \\cdot )$ denotes the operations of two Convs. ",
+        "bbox": [
+            173,
+            801,
+            514,
+            816
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            833,
+            403,
+            847
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In our proposed SRGRN, like the previous method (Lim et al., 2017), the number of GRUM depends on the scaling factor. For Conv layers with kernel size $3 \\times 3$ , we pad zeros to keep size fixed. We set the reduction ratio in bottleneck as $\\alpha$ . The number of nodes in the graph model is set to N. We utilize Leaky ReLu (Maas et al., 2013) with a negative slope of 0.2 as non-linear activation function. The feature extraction part of the network are the same as the RDN (Zhang et al., 2018b) settings. The final Conv layer has 1 or 3 output channels, as we output gray or color HR images. ",
+        "bbox": [
+            173,
+            848,
+            826,
+            933
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            326,
+            117
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SETTINGS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            125,
+            285,
+            138
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Datasets and Metrics. We train all our models using 800 training images in the DIV2K (Agustsson & Timofte., 2017) dataset, which contains high-quality 2K images that can be used for image superresolution task. And We use five standard benchmark datasets to evaluate PSNR and SSIM (Wang et al., 2004) metrics: Set5 (Bevilacqua et al., 2012), Set14 (Zeyde et al., 2010), B100 (Martin et al., 2001), Urban100 (Huang et al., 2015) and Manga109 (Y.Matsui et al., 2017). The SR results are evaluated on Y channel of transformed YCbCr space. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            223
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Degradation Models. In order to make a fair comparison with existing models, bicubic dowmsampling(denoted as BI) is regarded as a standard degradation model. We use it to generate LR images with scaling factor $\\times 2$ , $\\times 3$ , and $\\times 4$ from ground truth HR images. To fully demonstrate the effectiveness of our model, we also use two other degradation models and conduct special experiments for them. Our second model, we defined it as BD, which blurs HR images with a Gaussian kernel of size $7 \\times 7$ and a standard deviation of 1.6, and then downsamples the image with scaling factor $\\times 3$ In addition to BI and BD, we also built the DN model, which first performs bicubic downsampling with scaling factor $\\times 3$ and then adds Gaussian noise with a noise level of 30. ",
+        "bbox": [
+            173,
+            229,
+            825,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training Setting. In each training batch, 16 LR RGB patches of size $4 8 \\times 4 8$ are extracted as inputs. We perform data enhancement on the training images, which are randomly rotated by $9 0 °$ , $1 8 0 ^ { \\circ }$ , $2 7 0 ^ { \\circ }$ and flipped horizontally. We use the Adam optimizer to update the parameters of the network with $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ , and $\\epsilon = 1 0 ^ { - 8 }$ . For all layers in the network, the initial learning rate is set to 0.0001, and then the learning rate is halved every 200 epochs. We use the Pytorch framework to implement our model with Tesla P100. ",
+        "bbox": [
+            173,
+            348,
+            825,
+            433
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 ABLATION INVESTIGATION AND STUDY OF PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            440,
+            612,
+            455
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Global reasoning upsampling module. In order to verify the importance of the GRUM, we remove the GRUM from the network, leaving only the GRRB in the network for relation reasoning. As shown in Table 1, after removing GRUM, the performance of the network drops from $3 2 . 4 5 { \\mathrm { ~ d B } }$ to $3 2 . 4 0 ~ \\mathrm { d B }$ . When the Case Index is equal to 1, the corresponding model is the baseline model. We can observe that after GRUM is added to the baseline model, the network performance is improved from 32.31 dB to $3 2 . 4 2 \\ : \\mathrm { d B }$ . It can be seen that although our baseline model has achieved quite good results, GRUM can still improve the performance by relation reasoning in upsample module. This also indicates that relation reasoning can indeed result in better prformance. These comparisons fairly demonstrate the effectiveness of the GRUM for SR tasks. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            592
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Global reasoning reconstruction block. Then, we continue to study the effectiveness of GRRB for the network. After we add the GRRB to the baseline model, GRRB improves the performance of the model from 32.31 dB to $3 2 . 4 0 ~ \\mathrm { d B }$ . Furthermore, the model with GRUM has achieved good performance. And it is difficult to obtain further improvements. But when we add the GRRB to it, the network performance shows a significant improvement, and the PSNR value on Set5 increases from 32.42 dB to 32.45 dB. These indicates that it is very essential for our network. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            683
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Basic parameters. Moreover, we also study the effects of two basic parameters $N$ and $\\alpha$ on the performance of the model. As shown in Table 1, we observe that larger $N$ and smaller $\\alpha$ would lead to higher performance. Considering that larger $N$ and smaller $\\alpha$ will also bring more computation, we set 10 and 8 as the value of $N$ and $\\alpha$ respectively. ",
+        "bbox": [
+            174,
+            689,
+            825,
+            746
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/6c775b461aae7554d0a8c9e260f0c99c472266c25537cd581ab1468076e6921f.jpg",
+        "table_caption": [
+            "Table 1: Ablation investigation of global reasoning upsampling method and global reasoning reconstruction block, study of $\\mathbf { N }$ and $\\alpha$ . We observe the best PSNR values on Set5 with scaling factor $\\times 4$ in 200 epochs "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>CaseIndex</td><td>1</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td>7</td><td>8</td></tr><tr><td>Global reasoning upsampling module Global reasoning reconstruction block</td><td>×</td><td>√</td><td>×</td><td>√</td><td>√</td><td>√</td><td>√</td><td>√</td></tr><tr><td>Number of Node (N)</td><td>× -</td><td>× 10</td><td>√ 10</td><td>√ 10</td><td>√ 8</td><td>√ 6</td><td>√ 8</td><td>√ 6</td></tr><tr><td>reduction ratio (α)</td><td>-</td><td>8</td><td>8</td><td>8</td><td>8</td><td>8</td><td>16</td><td>16</td></tr><tr><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td><td></td></tr><tr><td>PSNRonSet5 (4×)</td><td>32.31</td><td>32.42</td><td>32.40</td><td>32.45</td><td>32.43</td><td>32.42</td><td>32.42</td><td>32.40</td></tr></table>",
+        "bbox": [
+            245,
+            799,
+            751,
+            862
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 NETWORK PARAMETERS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            385,
+            882
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Several state-of-the-art methods are compared with our SRGRN in this section. We show comparisons about model size and performance in Figure 4. Although our SRGRN has less parameter ",
+        "bbox": [
+            176,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "number than that of EDSR, MDSR and D-DBPN, our SRGRN and ${ \\mathrm { S R G R N } } +$ achieve higher performance, having a better tradeoff between model size and performance. This demonstrates our method can well balance the number of parameters and the reconstruction performance. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            146
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/fa0afa494b6350f18c6b633ca24483caf93fa8cea5b841529c6ffdd565fc5a42.jpg",
+        "image_caption": [
+            "Figure 4: The results are evaluated on the Set5 dataset for $4 \\times \\mathrm { S R }$ . The proposed SRGRN strikes a balance between the number of parameters and the reconstruction effect. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            356,
+            166,
+            635,
+            327
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e7e705951a361946176f4b8afeb6e695641871e1d7d762d1b62160a53d9afee9.jpg",
+        "table_caption": [
+            "Table 2: Average PSNR/SSIM for scale factors $\\times 2$ , $\\times 3$ and $\\times 4$ with BI degradation model. Best results are highlighted "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">scale</td><td colspan=\"2\">Set5</td><td colspan=\"2\">Set14</td><td colspan=\"2\">BSDS100</td><td colspan=\"2\">Urban100</td><td colspan=\"2\">Manga109</td></tr><tr><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td rowspan=\"9\"></td><td>33.66</td><td>0.9299</td><td>30.24</td><td>0.8688</td><td>29.56</td><td>0.8431</td><td>26.88</td><td>0.8403</td><td>30.80</td><td>0.9339</td></tr><tr><td>SRCNN</td><td>36.66</td><td>0.9542</td><td>32.45</td><td>0.9067</td><td>31.36</td><td>0.8879</td><td>29.50</td><td>0.8946</td><td>35.60</td><td>0.9663</td></tr><tr><td>DRRN</td><td>37.74</td><td>0.9591</td><td>33.23</td><td>0.9136</td><td>32.05</td><td>0.8973</td><td>31.23</td><td>0.9188</td><td>37.60</td><td>0.9736</td></tr><tr><td>LapSRN</td><td>37.52</td><td>0.9591</td><td>33.08</td><td>0.9130</td><td>31.08</td><td>0.8950</td><td>30.41</td><td>0.9101</td><td>37.27</td><td>0.9740</td></tr><tr><td>EDSR</td><td>38.11</td><td>0.9602</td><td>33.92</td><td>0.9195</td><td>32.32</td><td>0.9013</td><td>32.93</td><td>0.9351</td><td>39.10</td><td>0.9773</td></tr><tr><td>RDN</td><td>32.24</td><td>0.9614</td><td>34.01</td><td>0.9212</td><td>32.34</td><td>0.9017</td><td>32.89</td><td>0.9353</td><td>39.18</td><td>0.9780</td></tr><tr><td>SRFBN</td><td>38.11</td><td>0.9609</td><td>33.82</td><td>0.9196</td><td>32.29</td><td>0.9010</td><td>32.62</td><td>0.9328</td><td>39.08</td><td>0.9779</td></tr><tr><td>SRGRN(ours)</td><td>38.25</td><td>0.9614</td><td>34.06</td><td>0.9214</td><td>32.37</td><td>0.9022</td><td>33.12</td><td>0.9367</td><td>39.31</td><td>0.9783</td></tr><tr><td>SRGRN+(ours)</td><td>38.31</td><td>0.9616</td><td>34.15</td><td>0.9220</td><td>32.43</td><td>0.9027</td><td>33.32</td><td>0.9382</td><td>39.51</td><td>0.9786</td></tr><tr><td>Bicubic</td><td rowspan=\"9\"></td><td>30.39</td><td>0.8682</td><td>27.55</td><td>0.7742</td><td>27.21</td><td>0.7385</td><td>24.46</td><td>0.7349</td><td>26.95</td><td>0.8556</td></tr><tr><td>SRCNN</td><td>32.75</td><td>0.9090</td><td>29.30</td><td>0.8215</td><td>28.41</td><td>0.7863</td><td>26.24</td><td>0.7989</td><td>30.48</td><td>0.9117</td></tr><tr><td>DRRN</td><td>34.03</td><td>0.9244</td><td>29.96</td><td>0.8349</td><td>28.95</td><td>0.8004</td><td>27.53</td><td>0.8378</td><td>32.42</td><td>0.9359</td></tr><tr><td>LapSRN</td><td>33.82</td><td>0.9227</td><td>29.87</td><td>0.8320</td><td>28.82</td><td>0.7980</td><td>27.07</td><td>0.8280</td><td>32.21</td><td>0.9350</td></tr><tr><td>EDSR</td><td>34.65</td><td>0.9280</td><td>30.52</td><td>0.8462</td><td>29.25</td><td>0.8093</td><td>28.80</td><td>0.8653</td><td>34.17</td><td>0.9476</td></tr><tr><td>RDN</td><td>34.71</td><td>0.9296</td><td>30.57</td><td>0.8468</td><td>29.26</td><td>0.8093</td><td>28.80</td><td>0.8653</td><td>34.13</td><td>0.9484</td></tr><tr><td>SRFBN</td><td>34.70</td><td>0.9292</td><td>30.51</td><td>0.8461</td><td>29.24</td><td>0.8084</td><td>28.73</td><td>0.8641</td><td>34.18</td><td>0.9481</td></tr><tr><td>SRGRN(ours)</td><td>34.72 34.79</td><td>0.9297</td><td>30.60</td><td>0.8474</td><td>29.29</td><td>0.8102</td><td>28.95</td><td>0.8675</td><td>34.28</td><td>0.9491</td></tr><tr><td>SRGRN+(ours)</td><td></td><td>0.9301</td><td>30.69</td><td>0.8487</td><td>29.36</td><td>0.8114</td><td>29.11</td><td>0.8705</td><td>34.58</td><td>0.9506</td></tr><tr><td>Bicubic</td><td rowspan=\"9\"></td><td>28.42</td><td>0.8104</td><td>26.00</td><td>0.7027</td><td>25.96</td><td>0.6675</td><td>23.14</td><td>0.6577</td><td>24.89</td><td>0.7866</td></tr><tr><td>SRCNN</td><td>30.48</td><td>0.8628</td><td>27.50</td><td>0.7513</td><td>26.90</td><td>0.7101</td><td>24.52</td><td>0.7221</td><td>27.58</td><td>0.8555</td></tr><tr><td>DRRN</td><td>31.68</td><td>0.8888</td><td>28.21</td><td>0.7721</td><td>27.38</td><td>0.7284</td><td>25.44</td><td>0.7638</td><td>29.18</td><td>0.8914</td></tr><tr><td>LapSRN</td><td>31.54</td><td>0.8850</td><td>28.19</td><td>0.7720</td><td>27.32</td><td>0.7270</td><td>25.21</td><td>0.7560</td><td>29.09</td><td>0.8900</td></tr><tr><td>EDSR</td><td>32.46</td><td>0.8968</td><td>28.80</td><td>0.7876</td><td>27.71</td><td>0.7420</td><td>26.64</td><td>0.8033</td><td>31.02</td><td>0.9148</td></tr><tr><td>RDN</td><td>32.47</td><td>0.8990</td><td>28.81</td><td>0.7871</td><td>27.72</td><td>0.7419</td><td>26.61</td><td>0.8028</td><td>31.00</td><td>0.9151</td></tr><tr><td>SRFBN</td><td>32.47</td><td>0.8983</td><td>28.81</td><td>0.7868</td><td>27.72</td><td>0.7409</td><td>26.60</td><td>0.8015</td><td>31.15</td><td>0.9160</td></tr><tr><td>SRGRN(ours)</td><td>32.56</td><td>0.8997</td><td>28.84</td><td>0.7880</td><td>27.75</td><td>0.7428</td><td>26.73</td><td>0.8053</td><td>31.13</td><td>0.9164</td></tr><tr><td>SRGRN+(ours)</td><td>32.68</td><td>0.9009</td><td>28.95</td><td>0.7903</td><td>27.83</td><td>0.7445</td><td>26.94</td><td>0.8106</td><td>31.52</td><td>0.9197</td></tr></table>",
+        "bbox": [
+            222,
+            406,
+            774,
+            685
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 RESULTS WITH BI DEGRADATION MODEL ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            703,
+            506,
+            718
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For BI degradation model, we compare our proposed SRGRN and ${ \\mathrm { S R G R N } } +$ with other seven stateof-the-art image SR methods in quantitative terms. Following the previous works (Lim et al., 2017; Zhang et al., 2018b; Li et al., 2019), we also introduced a self-ensemble strategy to further improve the performance. We denote the self-ensemble method as ${ \\mathrm { S R G R N } } +$ . ",
+        "bbox": [
+            174,
+            729,
+            825,
+            785
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "A quantitative result for $\\times 2 , \\times 3$ , and $\\times 4$ is shown in Table 2. We compare our models with other state-of-the-art methods on PSNR and SSIM. It can be seen that our proposed SRGRN outperforms other methods on all datasets without adding self-ensemble. After adopting self-ensemble, the performance further improves on the basis of SRGRN, and it achieved the best on all datasets. It is worth mentioning that SRFBN (Li et al., 2019) uses DIV2K $+$ Flickr2K as their training set, which employs more training images than us. Previous research has come to a conclusion that more data in training set leads to a better result. However, their results are still not comparable to ours. Although RDN (Zhang et al., 2018b) is a state-of-the-art method, our SRGRN can achieve better performance in all datasets through relational reasoning in upsampling and reconstruction parts. The quantitative results indicate that our GRUM and GRRB play a vital role in improving network performance. ",
+        "bbox": [
+            173,
+            792,
+            825,
+            931
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.5 RESULTS WITH BD AND DN DEGRADATION MODELS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            103,
+            584,
+            117
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To show the robustness of the model, we also show the SR results with BD degradation model and further introduce DN degradation model. We compare $3 \\times \\mathrm { S R }$ results with other seven state-of-theart image SR methods in quantitative terms. And We re-train SRCNN (Dong et al.) and VDSR (Kima et al., 2016) for BD and DN degradation model because of mismatched degradation model. For BD and DN, there is no doubt that reconstruction has become more difficult. As shown in Table 3 and Table 4, in the case of images with a lot of artifacts and noise, our SRGRN can get a excellent performance. This shows that SRGRN can effectively denoise and alleviate blurring artifacts. And when added to self-ensemble, SRGRN $^ +$ can achieve a better improvement. ",
+        "bbox": [
+            173,
+            131,
+            825,
+            243
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/89e99f68e675d4a60e9913203736a4c391c8dbd40168ded673335dc64bcdc0c8.jpg",
+        "table_caption": [
+            "Table 3: Average PSNR/SSIM for scale factors $\\times 3$ with BD degradation model. Best results are highlighted "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">scale</td><td colspan=\"2\">Set5</td><td colspan=\"2\">Set14</td><td colspan=\"2\">BSDS100</td><td colspan=\"2\">Urban100</td><td colspan=\"2\">Manga109</td></tr><tr><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td rowspan=\"9\"></td><td>28.78</td><td>0.8308</td><td>26.38</td><td>0.7271</td><td>26.33</td><td>0.6918</td><td>23.52</td><td>0.6862</td><td>25.46</td><td>0.8149</td></tr><tr><td>SRCNN</td><td>32.05</td><td>0.8944</td><td>28.80</td><td>0.8074</td><td>28.13</td><td>0.7736</td><td>25.70</td><td>0.7770</td><td>29.47</td><td>0.8924</td></tr><tr><td>VDSR</td><td>33.25</td><td>0.9150</td><td>29.46</td><td>0.8244</td><td>28.57</td><td>0.7893</td><td>26.61</td><td>0.8136</td><td>31.06</td><td>0.9234</td></tr><tr><td>IRCNN_G</td><td>33.38</td><td>0.9182</td><td>29.63</td><td>0.8281</td><td>28.65</td><td>0.7922</td><td>26.77</td><td>0.8154</td><td>31.15</td><td>0.9245</td></tr><tr><td>IRCNN_C</td><td>×3 33.17</td><td>0.9157</td><td>29.55</td><td>0.8271</td><td>28.49</td><td>0.7886</td><td>26.47</td><td>0.8081</td><td>31.13</td><td>0.9236</td></tr><tr><td>SRMDNF</td><td>34.09</td><td>0.9242</td><td>30.11</td><td>0.8364</td><td>28.98</td><td>0.8009</td><td>27.50</td><td>0.8370</td><td>32.97</td><td>0.9391</td></tr><tr><td>RDN</td><td>34.57</td><td>0.9280</td><td>30.53</td><td>0.8447</td><td>29.23</td><td>0.8079</td><td>28.46</td><td>0.8581</td><td>33.97</td><td>0.9465</td></tr><tr><td>SRGRN(ours)</td><td>34.66</td><td>0.9286</td><td>30.60</td><td>0.8460</td><td>29.27 29.35</td><td>0.8090</td><td>28.71</td><td>0.8633</td><td>34.27</td><td>0.9480</td></tr><tr><td>SRGRN+(ours)</td><td>34.78</td><td>0.9295</td><td>30.71</td><td>0.8476</td><td></td><td>0.8104</td><td>28.96</td><td>0.8673</td><td>34.65</td><td>0.9498</td></tr></table>",
+        "bbox": [
+            238,
+            290,
+            758,
+            393
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/44ec0995e55af244e0a9d5a13fd01d00a1d01bb6f3da8cb6af28e0c2922d1deb.jpg",
+        "table_caption": [
+            "Table 4: Average PSNR/SSIM for scale factors $\\times 3$ with DN degradation model. Best results are highlighted "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=\"2\">Method</td><td rowspan=\"2\">scale</td><td colspan=\"2\">Set5</td><td colspan=\"2\">Set14</td><td colspan=\"2\">BSDS100</td><td colspan=\"2\">Urban100</td><td colspan=\"2\">Manga109</td></tr><tr><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td><td>PSNR</td><td>SSIM</td></tr><tr><td>Bicubic</td><td rowspan=\"9\"></td><td>24.01</td><td>0.5369</td><td>22.87</td><td>0.4724</td><td>22.92</td><td>0.4449</td><td>21.63</td><td>0.4687</td><td>23.01</td><td>0.5381</td></tr><tr><td>SRCNN</td><td>25.01</td><td>0.6950</td><td>23.78</td><td>0.5898</td><td>23.76</td><td>0.5538</td><td>21.90</td><td>0.5737</td><td>23.75</td><td>0.7148</td></tr><tr><td>VDSR</td><td>25.20</td><td>0.7183</td><td>24.00</td><td>0.6112</td><td>24.00</td><td>0.5749</td><td>22.22</td><td>0.6096</td><td>24.20</td><td>0.7525</td></tr><tr><td>IRCNN_G</td><td>25.70</td><td>0.7379</td><td>24.45</td><td>0.6305</td><td>24.28</td><td>0.5900</td><td>22.90</td><td>0.6429</td><td>24.88</td><td>0.7765</td></tr><tr><td>IRCNN_C</td><td>27.48</td><td>0.7925</td><td>25.92</td><td>0.6932</td><td>25.55</td><td>0.6481</td><td>23.93</td><td>23.93</td><td>26.07</td><td>0.8253</td></tr><tr><td>RDN</td><td>28.46</td><td>0.8151</td><td>26.60</td><td>0.7101</td><td>25.93</td><td>0.6573</td><td>24.92</td><td>0.7362</td><td>28.00</td><td>0.8590</td></tr><tr><td>SRFBN</td><td>28.53</td><td>0.8182</td><td>26.60</td><td>0.7144</td><td>25.95</td><td>0.6625</td><td>24.99</td><td>0.7424</td><td>28.02</td><td>0.8618</td></tr><tr><td>SRGRN(ours)</td><td>28.62 28.67</td><td>0.8195</td><td>26.66 26.73</td><td>0.7151</td><td>25.99 26.07</td><td>0.6632</td><td>25.14</td><td>0.7462</td><td>28.11</td><td>0.8642</td></tr><tr><td>SRGRN+(ours)</td><td></td><td>0.8206</td><td></td><td>0.7168</td><td></td><td>0.6645</td><td>25.31</td><td>0.7496</td><td>28.31</td><td>0.8674</td></tr></table>",
+        "bbox": [
+            238,
+            443,
+            758,
+            546
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.6 SUPER-RESOLUTION ON REAL-WORLD IMAGES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            560,
+            545,
+            574
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "To prove that our SRGRN can be widely used in the real world and performs robustly, we also conduct SR experiments on representative real-world images. We reconstruct some low resolution images in the real world that lack a lot of high frequency information. Moreover, in this case, the original HR images are not available and the degradation model is unknown either. Experiments show our SRGRN can recover finer and more faithful real-world images than other state-of-the-art methods under this bad condition. This further reflects the superiority of relation reasoning. ",
+        "bbox": [
+            173,
+            588,
+            825,
+            671
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            686,
+            318,
+            703
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this paper, inspired by the process of reconstructing images from the human visual system, we propose an super-resolution global reasoning network (SRGRN) for image SR, which aims at completing the reconstruction of SR images through global reasoning. We mainly propose global reasoning upsampling module (GRUM) and global reasoning reconstruction block (GRRB) as the core of the network. The GRUM can give the upsampling module the ability to perform relational reasoning in a global scope, which allows this process to overcome the limitations of the receptive field and recover more faithful details by analyzing more contextual information. The GRRB also enables the reconstruction block to make full use of the interaction between the regions and pixels to reconstruct SR images. We exploit SRGRN not only to handle low resolution images that are corrupted by three degradation model, but also to handle real-world images. Extensive benchmark evaluations demonstrate the importance of GRUM and GRRB. It also indicates that our SRGRN achieves superiority over state-of-the-art methods through global reasoning. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            888
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements. This research is supported by National Key R&D Program of China under grant 2018YFC0831503 ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            287,
+            117
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Eirikur Agustsson and Radu Timofte. Ntire 2017 challenge on single image super-resolution: Dataset and study. 2017. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Namhyuk Ahn, Byungkon Kang, and Kyung-Ah Sohn. Fast, accurate, and lightweight superresolution with cascading residual network. ",
+        "bbox": [
+            174,
+            162,
+            823,
+            191
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Marco Bevilacqua, Aline Roumy, Christine Guillemot, and Marie-Line Alberi Morel. Lowcomplexity single-image super-resolution based on nonnegative neighbor embedding. 2012. ",
+        "bbox": [
+            174,
+            199,
+            823,
+            228
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Chariker, Robert Shapley, and Lai-Sang Young. Orientation selectivity from very sparse lgn inputs in a comprehensive model of macaque v1 cortex. 2016. ",
+        "bbox": [
+            173,
+            236,
+            823,
+            266
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Logan Chariker, Robert Shapley, and Lai-Sang Young. Rhythm and synchrony in a cortical network model. 2018. ",
+        "bbox": [
+            174,
+            273,
+            823,
+            303
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yunpeng Chen, Marcus Rohrbach, Zhicheng Yan, Shuicheng Yan, Jiashi Feng, and Yannis Kalantidis. Graph-based global reasoning networks. 2018. ",
+        "bbox": [
+            174,
+            310,
+            825,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chao Dong, Chen Change Loy, Kaiming He, and Xiaoou Tang. Learning a deep convolutional network for image super-resolution. ",
+        "bbox": [
+            174,
+            347,
+            825,
+            377
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chao Dong, Chen Change Loy, and Xiaoou Tang. Accelerating the super-resolution convolutional neural network. 2016. ",
+        "bbox": [
+            174,
+            385,
+            825,
+            414
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Muhammad Haris, Greg Shakhnarovich, and Norimichi Ukita. Deep back projection networks for super-resolution. 2018. ",
+        "bbox": [
+            174,
+            421,
+            825,
+            450
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Gao Huang, Zhuang Liu, Laurens van der Maaten, and Kilian Q. Weinberger. Densely connected convolutional networks. 2017. ",
+        "bbox": [
+            174,
+            458,
+            823,
+            488
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jia-Bin Huang, Abhishek Singh, and Narendra Ahuja. Single image super-resolution from transformed self-exemplars. 2015. ",
+        "bbox": [
+            173,
+            496,
+            823,
+            525
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiwon Kim, Jung Kwon Lee, and Kyoung Mu Lee. Deeply-recursive convolutional network for image super-resolution. 2016. ",
+        "bbox": [
+            173,
+            532,
+            821,
+            563
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jiwon Kima, Jung Kwon Lee, and Kyoung Mu Lee. Accurate image super-resolution using very deep convolutional networks. 2016. ",
+        "bbox": [
+            173,
+            570,
+            821,
+            599
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wei-Sheng Lai, Jia-Bin Huang, Narendra Ahuja, and Ming-Hsuan Yang. Deep laplacian pyramid networks for fast and accurate super-resolution. 2017. ",
+        "bbox": [
+            173,
+            607,
+            821,
+            637
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Christian Ledig, Lucas Theis, Ferenc Huszar, Jose Caballero, Andrew Cunningham, Alejandro t’ Acosta, Andrew Aitken, Alykhan Tejani, Johannes Totz, Zehan Wang, and Wenzhe Shi. Photorealistic single image super-resolution using a generative adversarial network. 2017. ",
+        "bbox": [
+            173,
+            643,
+            826,
+            688
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Juncheng Li, Faming Fang, Kangfu Mei, and Guixu Zhang. Multi-scale residual network for image super-resolution. 2018. ",
+        "bbox": [
+            171,
+            695,
+            821,
+            724
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Zhen Li, Jinglei Yang, Zheng Liu, Xiaomin Yang, Gwanggil Jeon, and Wei Wu. Feedback network for image super-resolution. 2019. ",
+        "bbox": [
+            173,
+            732,
+            821,
+            762
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bee Lim, Sanghyun Son, Heewon Kim, Seungjun Nah, and Kyoung Mu Lee. Enhanced deep residual networks for single image super-resolution. 2017. ",
+        "bbox": [
+            174,
+            770,
+            821,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yong Liu, Ruiping Wang, Shiguang Shan, and Xilin Chen. Structure inference net: Object detection using scene-level context and instance-level relationships. 2018. ",
+        "bbox": [
+            174,
+            806,
+            821,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Andrew L. Maas, Awni Y. Hannun, and Andrew Y. Ng. Rectifier nonlinearities improve neural network acoustic models. 2013. ",
+        "bbox": [
+            174,
+            843,
+            821,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Martin, Charless Fowlkes, Doron Tal, and Jitendra Malik. A database of human segmented natural images and its application to evaluating segmentation algorithms and measuring ecological statistics. 2001. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tomer Peleg and Michael Elad. A statistical prediction model based on sparse representations for single image super-resolution. 2014. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adam Santoro, David Raposo, David G.T. Barrett, Mateusz Malinowski, Razvan Pascanu, Peter Battaglia, and Timothy Lillicrap. A simple neural network module for relational reasoning. 2017. ",
+        "bbox": [
+            171,
+            141,
+            825,
+            170
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Samuel Schulter, Christian Leistner, and Horst Bischof. Fast and accurate image upscaling with super-resolution forests. 2015. ",
+        "bbox": [
+            173,
+            178,
+            823,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Wenzhe Shi, Jose Caballero, Ferenc Huszár, Johannes Totz, Andrew P. Aitken, Rob Bishop, Daniel Rueckert, and Zehan Wang. Real-time single image and video super-resolution using an efficient sub-pixel convolutional neural network. 2016. ",
+        "bbox": [
+            176,
+            215,
+            823,
+            260
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ying Tai, Jian Yang, and Xiaoming Liu. Image super-resolution via deep recursive residual network. 2017. ",
+        "bbox": [
+            171,
+            267,
+            825,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Radu Timofte, Vincent De Smet, and Luc Van Gool. Anchored neighborhood regression for fast example-based super-resolution. 2013. ",
+        "bbox": [
+            174,
+            305,
+            823,
+            335
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Radu Timofte, Vincent De Smet, and Luc Van Gool. $\\mathbf { A } +$ : Adjusted anchored neighborhood regression for fast super-resolution. 2014. ",
+        "bbox": [
+            171,
+            343,
+            825,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tong Tong, Gen Li, Xiejie Liu, and Qinquan Gao. Image super-resolution using dense skip connections. 2017. ",
+        "bbox": [
+            173,
+            381,
+            825,
+            410
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Xintao Wang, Ke Y, Shixiang W, Jinjin Gu, Yihao Liu, Chao Dong, Chen Change Loy, Yu Qiao, and Xiaoou Tang. Esrgan: Enhanced super-resolution generative adversarial networks. 2018. ",
+        "bbox": [
+            174,
+            419,
+            823,
+            448
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Zhou Wang, Alan Conrad Bovik, Hamid Rahim Sheikh, and Eero P. Simoncelli. Image quality assessment: from error visibility to structural similarity. 2004. ",
+        "bbox": [
+            176,
+            457,
+            821,
+            486
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Y.Matsui, K.Ito, Y.Aramaki, A.Fujimoto, T.Ogawa, T.Ya masaki, and K. Aizawa. Sketch-based manga retrieval using manga109 dataset. 2017. ",
+        "bbox": [
+            174,
+            494,
+            820,
+            523
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew D. Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. 2014. ",
+        "bbox": [
+            176,
+            531,
+            813,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew D. Zeiler, Dilip Krishnan, Graham W. Taylor, and Rob Fergus. Deconvolutional networks. 2010. ",
+        "bbox": [
+            174,
+            555,
+            823,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Roman Zeyde, Michael Elad, and Matan Protter. On single image scale-up using sparserepresentations. 2010. ",
+        "bbox": [
+            174,
+            593,
+            823,
+            622
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kai Zhang, Wangmeng Zuo, and Lei Zhang. Learning a single convolutional super-resolution network for multiple degradations. 2018a. ",
+        "bbox": [
+            174,
+            631,
+            823,
+            661
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Kaibing Zhang, Xinbo Gao, Dacheng Tao, and . Xuelong Li. Single image super-resolution with non-local means and steering kernel regression. 2012. ",
+        "bbox": [
+            174,
+            669,
+            821,
+            699
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Lei Zhang and Xiaolin Wu. An edge-guided image interpolation algorithm via directional filtering and data fusion. 2006. ",
+        "bbox": [
+            173,
+            707,
+            823,
+            736
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yulun Zhang, Yapeng Tian, Yu Kong, Bineng Zhong, and Yun Fu. Residual dense network for image super-resolution. 2018b. ",
+        "bbox": [
+            173,
+            744,
+            823,
+            773
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A.1 VISUAL RESULT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            330,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Visual comparison with BI degradtion model. As shown in Figure 5, we show a visual comparison on $4 \\times$ SR. For image \"img_078\" from Urban100, we observe that most methods, even RDN and SRFBN, cannot recover these lattices and suffer from extremely severe blurring artifacts. Only our SRGRN can alleviate these blurring artifacts, recovers sharper and clearer edges and finer texture. For image \"MukoukizuNoChonbo\" from Manga109, There are heavy blurrings artifacts in all comparison methods, and the outline of some letters are broken. However, our proposed SRGRN can accurately recover these outlines, more faithful to the ground truth. The above comparison results are mainly due to the fact that SRGRN can enable upsampling and reconstruction modules to utilize more contextual information through relation reasoning. ",
+        "bbox": [
+            174,
+            160,
+            826,
+            285
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Visual comparison with BD and DN degradtion model. In Figure 6, we show the comparison of SRGRN with other models in visual results. For image \"img_ $. 0 1 4 \"$ , we use bicubic upsampling to recover these images whose HR images are blurred with a Gaussian kernel before bicubic downsampling, then we obtain SR images with a lot of noticeable blurring artifacts. We have also observed that most methods, including RDN and SRFBN, do not clearly recover the lines around the window. Only our SRGRN can suppress blurring artifacts and recover these clear enough lines close to the ground truth by relation reasoning. For image \"img $\\underline { { 0 0 2 } } \"$ , a large amount of noise corrupt the LR image and make it loss some detail. It can be seen that when using bicubic for upsampling, the obtained image not only has a large number of blurring artifacts but also a large amount of noise. However, we find that our SRGRN has great potential for removing noise efficiently and recover more detail. This fully demonstrates the effectiveness and robustness of our SRGRN for BD and DN degradation models. ",
+        "bbox": [
+            174,
+            291,
+            826,
+            458
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Visual comparison on Real-World Images. In figure 7, the resolution of these images is so small that there is a lot of high frequency information missing from them. Moreover, in this case, the original HR images are not available and the degradation model is unknown either. For image \"window\"(with $2 0 0 \\times 1 6 0$ pixels), only our SRGRN is able to recover sharper window edges and produce clearer SR image. For image \"flower\"(with $2 5 6 \\times 2 0 0$ pixels), most other methods recover images whose upper left corner produces the edge of the pistil that looks unreal. And their edges of the petals in the whole image are very blurry. Our SRGRN can recovers sharper edges and finer details than other state-of-the-art methods. The above analysis indicate our model perform robustly unknown degradation models. This further reflects the superiority of relation reasoning. ",
+        "bbox": [
+            173,
+            464,
+            825,
+            590
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/c1032250f11f2acd645ef1c518eaa984b8c9f85802e4332b84c97bd964adaf3b.jpg",
+        "image_caption": [
+            "Figure 5: Visual comparison for $4 \\times$ SR with BI model on \"img_078\" from Urban100 and \"MukoukizuNoChonbo\" from Manga109. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            608,
+            771,
+            801
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/e7ddcced9abf43c15cedfa2f4e7b02b00e080ce04b90f6d9422e29e100756858.jpg",
+        "image_caption": [
+            "Figure 6: Visual comparison for $3 \\times$ SR with BD model on \"img_014\" from Urban100 and for $3 \\times$ SR with DN model on \"img_002\" from Urban100 "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            227,
+            178,
+            766,
+            404
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/a0e9bf16cb54dd571ac899ba5f43da15c124d477eb5675bb5770a8726e7072aa.jpg",
+        "image_caption": [
+            "Figure 7: Visual comparison for $\\mathbf { 4 } \\times \\mathbf { S R }$ on real-world images. The two images show \"flowers\" and \"window\" respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            594,
+            771,
+            816
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJRpRfKxx/SJRpRfKxx.md

@@ -0,0 +1,308 @@
+# RECURRENT MIXTURE DENSITY NETWORK FOR SPATIOTEMPORAL VISUAL ATTENTION
+
+Loris Bazzani∗   
+Amazon   
+Berlin, Germany   
+bazzanil@amazon.com   
+Hugo Larochelle†   
+Departement d’informatique ´   
+Universite de Sherbrooke´   
+hugo.larochelle@usherbrooke.ca   
+Lorenzo Torresani   
+Department of Computer Science   
+Dartmouth College   
+lt@dartmouth.edu
+
+# ABSTRACT
+
+In many computer vision tasks, the relevant information to solve the problem at hand is mixed with irrelevant, distracting information. This has motivated researchers to design attentional models that can dynamically focus on parts of images or videos that are salient, e.g., by down-weighting irrelevant pixels. In this work, we propose a spatiotemporal attentional model that learns where to look in a video directly from human fixation data. We model visual attention with a mixture of Gaussians at each frame. This distribution is used to express the probability of saliency for each pixel. Time consistency in videos is modeled hierarchically by: 1) deep 3D convolutional features to represent spatial and short-term time relations at clip level and 2) a long short-term memory network on top that aggregates the clip-level representation of sequential clips and therefore expands the temporal domain from few frames to seconds. The parameters of the proposed model are optimized via maximum likelihood estimation using human fixations as training data, without knowledge of the action in each video. Our experiments on Hollywood2 show state-of-the-art performance on saliency prediction for video. We also show that our attentional model trained on Hollywood2 generalizes well to UCF101 and it can be leveraged to improve action classification accuracy on both datasets.
+
+# 1 INTRODUCTION
+
+Attentional modeling and saliency prediction in images has been an active research topic in computer vision over the last decade. Interest in attentional models is primarily motivated by their ability to eliminate or down-weight pixels that are not important for the task at hand, as for example shown in prior work using visual attention for image recognition and caption generation (Sermanet et al., 2014; Xu et al., 2015; Mnih et al., 2014). Integrating visual attention in an image analysis model can potentially lead to improved overall accuracy, as the system can focus on the most salient regions in the photo without being disturbed by irrelevant information.
+
+Recently, we have witnessed a shift of trend from image saliency prediction (Borji & Itti, 2013) to the modeling of saliency in videos (Rudoy et al., 2013). Since human fixation patterns are strongly correlated over time (Coull, 2004), it appears critical to model the relations between saliency maps of consecutive frames. In this scenario, attention can be defined as a spatiotemporal volume, where each saliency map (one for each frame) depends on the frames at the previous times. The saliency map can be interpreted as a probability distribution over pixels and the actual fixation patterns can be generated by sampling from the the map.
+
+Going from images to videos is not straightforward, since videos bring up many challenges. First of all, videos have an additional dimension (time), compared to images. This causes a dramatic growth in the number of pixels to be processed and poses a significantly higher computational cost for analysis. At the same time, there are strong redundancies present in such data, which implies that visual attention may be particularly beneficial for the video setting. For example, typically the objects or people in a video do not change significantly in appearance over time. Yet, for analysis tasks such as action recognition (Wang & Schmid, 2013) or video description (Yao et al., 2015), it is imperative to properly model the dynamical properties of these objects in the video. This suggests that, in order to identify spatiotemporal volumes that are salient for video analysis, an attentional model must take into account high-level image semantics as well as the history of past fixations.
+
+In order to cope with these challenges, we propose an efficient spatiotemporal attentional model (see Fig. 1) that leverages deep 3D convolutional features (Tran et al., 2015) as semantic, spatiotemporal representation of short clips in the video. This clip-level representation is then aggregated by a Long Short-Term Memory (LSTM) network (Hochreiter & Schmidhuber, 1997), that expands the temporal range of analysis from few frames to seconds. The LSTM model connects into a Mixture Density Network (MDN) (Bishop, 1994) that at each frame outputs the parameters of a Gaussian mixture model expressing the saliency map. We refer to this model as Recurrent Mixture Density Network (RMDN). RMDN is trained via maximum likelihood estimation using human fixations as training data, without knowledge of the actions in the videos.
+
+The potential applications of automatic saliency map prediction from videos are many. They include attention-based video compression (Gitman et al., 2014), visual attention for robots (Yu et al., 2010), crowd analysis for video surveillance (Jiang et al., 2014), salient object detection (Li & Yu, 2015; Karthikeyan et al., 2015) and activity recognition (Vig et al., 2012; Sapienza et al., 2014). In this work we focus on a study of how visual attention may improve action recognition by leveraging the saliency map generated by RMDN for video classification. The idea is akin to soft attention and consists in re-weighting the pixel values of the input video by the estimated saliency map. Despite its simplicity, we show that the combination of features extracted from this modified version of the video and those computed from the original input lead to a significant improvement in action recognition, compared to a model that does not use attention.
+
+The primary contribution of this work is a spatiotemporal saliency estimation network optimized to reproduce human fixations. The proposed approach offers several advantages: 1) the model can be trained without having to engineer spatiotemporal features; 2) RMDN is directly trained on examples of human fixations and thus learns to mimic human visual attention; 3) prediction of the saliency map is very fast (it takes 0.08s per 16-frame clip on a GPU); 4) the method outperforms the state-of-the-art (Mathe & Sminchisescu, 2015) in saliency accuracy; 5) our predicted saliency maps lead to to improvements in action classification accuracy.
+
+# 2 RELATED WORK
+
+Broadly speaking, the literature on attentional models can be split into two categories: task-agnostic approaches which model the bottom-up, free-viewing properties of attention, and task-specific methods which model its top-down, task-driven properties. Researchers have devoted many years to create datasets, collecting human fixations and proposing solutions for biologically-plausible saliency estimators, built using low-level cues such as edge detectors and color filters (e.g. see Borji et al. (2013); Judd et al. (2009); Harel et al. (2006) for recent examples). We refer to Borji & Itti (2013) and Bruce et al. (2016) for an interesting analysis and comparison of existing methods. Most of the techniques in the literature are focused on extracting features in a bottom-up and/or top-down manner and use them to estimate the saliency map. In this context, motion features are introduced when extending saliency methods from images to videos (Guo et al., 2008; Zhao et al., 2015; Zhai & Shah, 2006). However, there is no explicit modeling of the temporal dimension that can capture long-term relations. In fact, motion features (e.g., optical flow) describe short-term associations at the temporal scale of only a few consecutive frames.
+
+Prior approaches can also be categorized into soft-attentional versus hard-attentional models. Softattentional models use the predicted saliency maps to down-weight pixels that are not relevant or salient, e.g., Song et al. (2016). Specifically deep networks have been used in this context to assign a weight to each pixel in order to extract “glimpses” from images (Xu et al., 2015; Gregor et al., 2015)
+
+or videos (Yao et al., 2015) in the form of weighted pixel averages. One strength of such approaches is that they can backpropagate through the attentional component and tune it in the context of its use in a deep network. Other work has been geared towards learning hard-attentional models, which explicitly ignore and discard parts of the input (Larochelle & Hinton, 2010; Bazzani et al., 2011; Denil et al., 2012; Mnih et al., 2014; Xu et al., 2015; Sermanet et al., 2014; Ba et al., 2015; Yoo et al., 2015; Zheng et al., 2015), thus providing significant computational savings. Unfortunately, such models are often hard to train because they rely on reinforcement learning techniques to generate the image/video locations during training.
+
+All of the aforementioned prior work attempts to learn attentional models indirectly rather than from explicit information of where humans look. Recent work (Mauthner et al., 2015; Hossein Khatoonabadi et al., 2015; Mathe & Sminchisescu, 2015; Stefan Mathe, 2013; Kummerer et al., 2015; Rudoy ¨ et al., 2013) has shown that it may be possible to accurately reproduce gazing patterns of human subjects attending to images and videos. However, these prior approaches rely on hand-crafted features to estimate the saliency maps. Attempts at removing hand-engineering of features are represented by Jetley et al. (2016); Huang et al. (2015); Kummerer et al. (2015) where networks pre-trained for ¨ object recognition were subsequently finetuned using saliency-based loss functions for images. Pan & i Nieto (2015) followed the same principle but without using any pre-trained network for initialization. Liu et al. (2015) proposed a multi-scale architecture for saliency prediction, and Li & Yu (2015) added a refinement step in order to enforce spatial coherence of the output. Simonyan et al. (2014) and Mahendran & Vedaldi (2016) proposed to reverse deep networks using deconvolutions for visualization and to estimate image saliency. However, these methods estimate saliency from still images and do not consider the temporal aspect of video. Chaabouni et al. (2016a;b) trained a ConvNet for saliency prediction on optical flow features and individual frames. However the model uses only the very short-term temporal relations of two consecutive frames.
+
+In this paper, we explore the following question: can deep networks be trained to reliably predict spatiotemporal attentional patterns, specifically in such a way that these predictions can be leveraged successfully by a recognition system? To our knowledge, our work distinguishes itself from the aforementioned literature by being the first application of deep networks to the prediction of spatiotemporal human saliency in videos.
+
+# 3 PROPOSED MODEL
+
+We start with a high-level description of our attentional model. We then formalize it in Sec. 3.1, and describe its training in Sec. 3.2. Sec. 3.3 reports how prediction is efficiently carried out at test time. Sec. 3.4 describes how to leverage the predicted saliency map to improve action recognition.
+
+The proposed RMDN model for saliency estimation is depicted in Fig. 1. At time $t$ , the input of the model is a sequence of the last $K = 1 6$ frames, i.e., from time $t - K + 1$ to current time $t$ . We refer to this sequence as the input “clip.” The first part of the model (Fig. 1, blue layers above the input clip) consists of a 3D convolutional network that provides a feature representation of the clip. Our choice of a clip-based representation rather than a single-frame descriptor is motivated by the fact that these features allow us to explicitly capture short-term information that is then aggregated for long-term spatiotemporal visual attention by RMDN. Furthermore, there is recently growing evidence (Tran et al., 2015; Srivastava et al., 2015; Yue-Hei $\mathrm { N g }$ et al., 2015) that by modeling the temporal information it is possible to obtain improved performances in high-level video analysis tasks, such as action recognition. For the computation of spatiotemporal features from the input clip, we use the “C3D” architecture proposed by Tran et al. (2015), which has been shown to provide competitive results on video recognition tasks across different datasets. The C3D architecture is defined as: C64-P-C128-P-C256-C256-P-C512-C512-P-C512-C512-P-FC4096-FC4096-softmax, where C is a 3D convolutional layer, P is the pooling layer, FC is a fully-connected layer, and the number specifies the number of kernels of the layer (e.g. C64 has 64 kernels). For the details about the size and stride of the convolutional and pooling kernels, we refer to (Tran et al., 2015).
+
+The convolutional network has access to a limited window of the video since it uses a fixed-size clip of 16 frames as input. In order to empower the visual attention model with the ability to take into account longer temporal extents, we need a mechanism that performs temporal aggregation of past clip-level signals. To this end, we propose to connect the internal representation of the C3D model to a recurrent neural network, as shown in Fig. 1 (green module). The aim of the temporal connections of the recurrent neural network is to propagate the clip-level features through time via memory units that can capture long-term dependencies. Our model uses LSTMs (Hochreiter & Schmidhuber, 1997) as memory blocks.
+
+![](images/7ce9041d8c9165e1166292f75ff66cb6039f8b1a93f4f581dac38779311070d9.jpg)  
+Figure 1: Proposed recurrent mixture density network for saliency prediction. The input clip of $K$ frames is fed into a 3D convolutional network (in blue), whose output becomes the input of a long short-term memory (LSTM) network (in green). Finally, a linear layer projects the LSTM representation to the parameters of a Gaussian mixture model, which describes the saliency map.
+
+The saliency map at each time $t$ is expressed in terms of a Gaussian Mixture Model (GMM) with $C$ components. We denote its parameters with $\{ ( \mu ^ { c } , \pi ^ { c } , \Sigma ^ { c } ) \} _ { c = 1 } ^ { C }$ , where $\mu ^ { c }$ , $\pi ^ { c }$ and $\Sigma ^ { c }$ are the mean, the mixture coefficient and the covariance of the $c$ -th Gaussian component, respectively. The LSTM directly outputs these parameters (see details below). The resulting network is known as a Mixture Density Network (MDN) (Bishop, 1994; Graves, 2013).
+
+Since the model is recurrent, there is a direct connection between the inner representation of the LSTM at time $t$ and the one at time $t + 1$ . This favors temporal consistency between the saliency maps at adjacent times.
+
+# 3.1 FORMALIZATION OF THE MODEL
+
+Let con $\mathcal { D } = \{ ( \mathbf { v } ^ { i } , \mathbf { a } ^ { i } ) \} _ { i = 1 } ^ { N }$ be a dataset of videosrally overlapping clips d human fixations pairs. (i.e., sampled with stride $\mathbf { v } ^ { i } = ( \mathbf { c } _ { t } ^ { i } ) _ { t = 0 } ^ { T _ { i } - 1 }$ $T _ { i }$ $\mathbf { c } _ { t } ^ { i }$ $\mathbf { a } ^ { i } = ( a _ { t } ^ { i } ) _ { t = 0 } ^ { T _ { i } - 1 }$ the sequence of ground-truth fixations for the $i$ -th video aligned with the clips. Since we use C3D to represent each clip, $\mathbf { c } _ { t } ^ { i }$ has a fixed length of $K = 1 6$ frames and $t = 0$ means that the first $K$ frames t are used to build the 0-th clip. The fixations $a _ { t } ^ { i } = \{ a _ { t , j } ^ { i } \} _ { j = 1 } ^ { A }$ are a set of $( x , y )$ image positions that are normalized to $[ 0 , 1 ]$ in order to deal with videos of different resolutions. The number of fixations vary from frame to frame in general, but in our experiments we control it via subsampling in order to obtain for each frame a set of fixed size $A$ .
+
+Let $\mathbf { x } _ { t } = \mathtt { C } 3 \mathtt { D } ( \mathbf { c } _ { t } )$ be the internal representation of C3D for an input clip $\mathbf { c } _ { t }$ . In our model we use the last convolutional layer, before the fully-connected layers. We choose a convolutional layer instead of a fully-connected layer because the latter discards spatial information, which is crucial to estimate a spatially-variant saliency map over the image.
+
+The LSTM network (Hochreiter & Schmidhuber, 1997) is defined as follows:
+
+$$
+\begin{array} { l l } { { f _ { t } = \sigma ( W _ { f } \cdot [ h _ { t - 1 } , { \bf x } _ { t } ] + b _ { f } ) , \quad \quad \quad } } & { { i _ { t } = \sigma ( W _ { i } \cdot [ h _ { t - 1 } , { \bf x } _ { t } ] + b _ { i } ) \quad \quad } } \\ { { o _ { t } = \sigma ( W _ { o } \cdot [ h _ { t - 1 } , { \bf x } _ { t } ] + b _ { o } ) , \quad \quad \quad } } & { { \tilde { C } _ { t } = \operatorname { t a n h } \left( W _ { C } \cdot [ h _ { t - 1 } , { \bf x } _ { t } ] + b _ { C } \right) } } \\ { { C _ { t } = f _ { t } * C _ { t - 1 } + i _ { t } * \tilde { C } _ { t } , \quad \quad \quad } } & { { h _ { t } = o _ { t } * \operatorname { t a n h } \left( C _ { t } \right) } } \end{array}
+$$
+
+where $f _ { t } , i _ { t } , o _ { t } , C _ { t }$ and $h _ { t }$ are the forget gate, the input gate, the output gate, the memory cell, and the hidden representation, respectively. The learning parameters that need to be estimated during the training phase are $W _ { z }$ and $b _ { z }$ ,where $z \in \{ f , i , o , C \}$ .
+
+The MDN (Graves, 2013; Bishop, 1994) takes its inputs from the hidden representation of the LSTM network. Since the output space is 2D (the space of image locations), we can reparametrize the model as $\{ ( \mu _ { t } ^ { c } , \pi _ { t } ^ { c } , \sigma _ { t } ^ { c } , \bar { \rho _ { t } ^ { c } } ) \} _ { c = 1 } ^ { C ^ { - } }$ , where $\mu _ { t } ^ { c }$ , $\pi _ { t } ^ { c }$ , $\sigma _ { t } ^ { c }$ and $\rho _ { t } ^ { c }$ are the 2D mean position, the weight, the 2D variance and the correlation of the $c$ -th Gaussian component, respectively. The MDN is therefore defined as follows:
+
+$$
+y _ { t } = \{ ( \tilde { \mu } _ { t } ^ { c } , \tilde { \pi } _ { t } ^ { c } , \tilde { \sigma } _ { t } ^ { c } , \tilde { \rho } _ { t } ^ { c } ) \} _ { c = 1 } ^ { C } = W _ { y } \cdot h _ { t } + b _ { y }
+$$
+
+where $W _ { y }$ and $b _ { y }$ are the parameters of the linear layer and $h _ { t }$ is the hidden representation of the LSTM network. The parameters of the GMM in Eq. 4 are normalized as follows in order to obtain a valid probability distribution:
+
+$$
+\mu _ { t } ^ { c } = \tilde { \mu } _ { t } ^ { c } , \quad \pi _ { t } ^ { c } = \frac { \exp ( \tilde { \pi } _ { t } ^ { c } ) } { \sum _ { i = 1 } ^ { C } \exp ( \tilde { \pi } _ { t } ^ { i } ) } , \quad \sigma _ { t } ^ { c } = \exp ( \tilde { \sigma } _ { t } ^ { c } ) , \quad \rho _ { t } ^ { c } = \operatorname { t a n h } \big ( \tilde { \rho } _ { t } ^ { c } \big ) .
+$$
+
+The composition of the LSTM and the MDN results in the RMDN.
+
+# 3.2 TRAINING
+
+The proposed model can be trained by optimizing the log-likelihood of the training ground truth fixations, $\mathbf { a } ^ { i }$ , under the GMM. The loss function for the $i$ -th video, $\mathbf { v } ^ { i }$ , is defined as the negative log-likelihood of the fixations under the GMM, as follows:
+
+$$
+L ( { \mathbf v } ^ { i } , \mathbf { a } ^ { i } ) = \sum _ { t = 0 } ^ { T _ { i } - 1 } \sum _ { j = 1 } ^ { A } - \log \left( \sum _ { c = 1 } ^ { C } \pi _ { t } ^ { c } { \mathcal N } ( a _ { t , j } ^ { i } ; \mu _ { t } ^ { c } , \sigma _ { t } ^ { c } , \rho _ { t } ^ { c } ) \right)
+$$
+
+where $\mathcal { N }$ is the Gaussian distribution. Note that the parameters of the Gaussian components depend on the input video $\mathbf { v } _ { i }$ , but we do not make this explicit in the equation in order to keep notation simple.
+
+The log-likelihood of the RMDN is optimized using backpropagation through time, since it is a composition of continuous functions (e.g. linear transformations and element-wise non-linearities) and the LSTM, for which we can compute the gradients. In particular, we refer to the paper of Graves (2013) for the derivation of the gradients for the MDN using the loss function of Eq. 6. In practice, due to the limited training data, we freeze the layers of the C3D network to the values pretrained by Tran et al. (2015) for action recognition. This implies that the low-level representation $\mathbf { x } _ { t }$ is fixed. We jointly train the LSTM and MDN from randomly initialized parameters.
+
+# 3.3 PREDICTION
+
+The inference stage is straightforward by following the equations of Sec. 3.1. At a given time $t$ , the clip from time $t - K + 1$ to $t$ is fed into the C3D network to produce the representation $\mathbf { x } _ { t }$ . This vector is passed to the LSTM (Eqs. 1, 2, and 3) whose hidden representation is passed to the MDN, which outputs the GMM parameters (Eqs. 4 and 5). In order to generate the final saliency map, we compute the probability of each pixel position under the GMM model. We normalize the probability map to sum up to 1 over the image pixels in order to produce a normalized saliency map.
+
+# 3.4 SALIENCY FOR CLASSIFICATION
+
+For the task of video classification, we generate a modified version of the video by using a softattentional mechanism: the idea is to weight each pixel value by the estimated saliency at that position. This operation effectively down-weights regions that are deemed not salient. The intuition is that then the classifier will be able to focus on the parts of the frame which are most relevant without being distracted by the non-salient regions (see Fig. 2 in Appendix A).
+
+At each time $t$ , we extract two representations: the “context” branch is given by the C3D representation of the original clip, while the “soft attentional” branch is given by the C3D representation of the input clip weighted by the saliency map. The rationale is that the context branch considers the global evolution of the activity in the video while the soft attentional branch is focused on the most-salient local evolution of the activity. The two representations are then concatenated at the clip level and max-pooled over the video to obtain the final video-level descriptor. This video-level representation is then used as input to train the video classifier, which is a linear SVM in all our experiments.
+
+# 4 EXPERIMENTS
+
+In this section, we evaluate the proposed method for both saliency prediction and action recognition on two challenging datasets: Hollywood2 (Marszałek et al., 2009) and UCF101 (Soomro et al., 2012). Section 4.1 reports a quantitative analysis for the task of saliency prediction. Section 4.2 shows the results for the action recognition task in two scenarios: 1) using the same dataset that was used to train the saliency predictor and 2) applying the pretrained attentional model to a neverseen dataset and a different set of actions. We reported the implementation details in Appendix B. We invite the reader to watch the qualitative results of the proposed method in the form of a video available at https://youtu.be/aXOwc17nx_s.
+
+# 4.1 SALIENCY PREDICTION
+
+The proposed model is trained using human fixation data. Few datasets provide both human fixations and class labels, which we need for the action recognition experiment discussed in the next section. Therefore, we used the Hollywood2 dataset, which was augmented with eye tracking data by Mathe & Sminchisescu (2015). We follow the same evaluation protocol (i.e., same training/test splits) of Mathe & Sminchisescu (2015) and their validation procedure to compute the final results in order to compare with their work. Mathe & Sminchisescu (2015) generate the ground truth saliency from a binary fixation map where the only non-zero values are at fixations points. The final saliency map is produced by convolving the binary map with an isotropic Gaussian filter with standard deviation $\sigma$ and then adding to it a uniform distribution with probability parameter $p$ . As in Mathe & Sminchisescu (2015), the values of these two parameters are chosen from $\sigma \in \{ 1 . 5 , 3 . 0 \}$ and $p \in \{ 0 . 2 5 , 0 . 5 \}$ via hold-out validation. We use a validation set consisting of $2 0 \%$ of the training set. We use the remaining $8 0 \%$ of the training data to learn our models, and use the hold-out validation set to choose the hyperpameters of our model.
+
+We evaluate all models on the test set, using popular metrics proposed in the literature of saliency map prediction for still images (Judd et al., 2012; Borji et al., 2013), such as Area Under the ROC Curve (AUC), Normalized Scanpath Saliency (NSS), linear Correlation Coefficient (CC) and the Similarity score (Sim). We refer to the papers of Judd et al. (2012) and Borji et al. (2013) for their detailed description.
+
+Table 1 shows results achieved with different variants of our model and a simple baseline method, which we refer to as Trained Central Bias (TCB). The TCB model is a single GMM trained using the fixations of all the videos in the training sets. TCB predicts the same saliency map for each testing frame, thus it discards completely the temporal information and the image input. This experiment shows that all versions of our RMDN consistently outperform TCB under all metrics, even when using a smaller number of fixations per frame during training.
+
+The different variants of RMDN in Table 1 explore the following design choices in our model: 1) the impact of using LSTM hidden units as opposed to regular RNN units (second and third row) and 2) the number of fixations per frame used for training (third and fourth row). These experiments show that LSTM (third row) is better than an RNN (second row) in terms of AUC and NSS, but in order to have better CC and Sim we need to use more fixations per frame (fourth row). This is intuitive: since the LSTM has many more parameters than the RNN, it needs more training data to be properly optimized.
+
+The last row in Table 1 shows the results obtained by retraining our model using the full training set of Mathe & Sminchisescu (2015) instead of just the $8 0 \%$ subset. For this case (RMDN full) we used the hyper-parameter values selected via hold out-validation for the experiment in the fourth row. This gives the best result for saliency prediction reported in our work and it is the model we used for all the subsequent experiments described below.
+
+All of the experiments reported in Table 1 were obtained using $C = 2 0$ components in the GMM. We have also studied how the accuracy varies by reducing the value of $C$ . For example, using the RMDN variant of row 5 in Table 1 but with $C = 1 0$ components (instead of 20), the performance does not change dramatically, yielding $\mathrm { A U C } = \mathrm { 0 . 8 9 6 6 }$ and $\mathrm { N S S } { = 2 . 4 3 9 2 }$ . On the other hand, the AUC and the NSS decrease considerably, by $1 . 3 \%$ and 0.3 points respectively, when using only $C = 2$ components $( \mathrm { A U C } = 0 . 8 8 3 6$ and $\mathrm { N S S } = 2 . 1 3 8 5$ ). Based on this analysis, in all our subsequent experiments we used $C = 2 0$ as we noticed that our approach implements automatically a sort of Occam’s razor, setting the weights $\pi _ { c }$ of many components close to zero when necessary.
+
+We have also carried out a few side experiments and discovered that using the fully-connected features of C3D instead of the convolutional representation gives results that are at least $1 . 5 \%$ lower in terms of AUC. Moreover, we tried to finetune the C3D network for action categorization on Hollywood2. However we did not obtain any significant improvement, confirming the findings of Tran et al. (2015): the C3D representation is already general enough to perform effectively on different action recognition tasks and fine-tuning the model on smaller-scale datasets (such as Hollywood2) does not seem beneficial. We also experimented with deep LSTMs, but we obtained an insignificant improvement of performance. For this reason and also because deep LSTMs have more parameters and are more computationally expensive to train, we chose to use a shallow one-layer LSTM. Finally, we run the ablation study where the recurrent link between time $t - 1$ and $t$ of the RMDN is removed: the results in terms of AUC are $1 . 2 \%$ and $2 . 4 \%$ lower with respect to the RMDN which uses RNN (second row of Table 1) and LSTM (third row of Table 1), respectively.
+
+Table 1: Accuracy of saliency prediction for the Trained Central Bias baseline and different variants of our RMDN model in terms of AUC, NSS, CC and Similarity. Training and testing are performed on disjoint splits of the Hollywood2 dataset.   
+
+<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Net(#units)</td><td rowspan=1 colspan=1>Fix. per frame</td><td rowspan=1 colspan=1>AUC</td><td rowspan=1 colspan=1>NSS</td><td rowspan=1 colspan=1>CC</td><td rowspan=1 colspan=1>Sim</td></tr><tr><td rowspan=1 colspan=1>Trained Central Bias</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>0.8725</td><td rowspan=1 colspan=1>1.7646</td><td rowspan=1 colspan=1>0.5297</td><td rowspan=1 colspan=1>0.4812</td></tr><tr><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>RNN(128)</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>0.8745</td><td rowspan=1 colspan=1>1.9505</td><td rowspan=1 colspan=1>0.5495</td><td rowspan=1 colspan=1>0.4962</td></tr><tr><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>LSTM(128)</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>0.8866</td><td rowspan=1 colspan=1>2.0155</td><td rowspan=1 colspan=1>0.4606</td><td rowspan=1 colspan=1>0.4219</td></tr><tr><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>LSTM(256)</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>0.8986</td><td rowspan=1 colspan=1>2.5169</td><td rowspan=1 colspan=1>0.6007</td><td rowspan=1 colspan=1>0.5278</td></tr><tr><td rowspan=1 colspan=1>RMDN full</td><td rowspan=1 colspan=1>LSTM(256)</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>0.9037</td><td rowspan=1 colspan=1>2.6455</td><td rowspan=1 colspan=1>0.6129</td><td rowspan=1 colspan=1>0.5349</td></tr></table>
+
+We also compared our approach to the state-of-the-art in saliency prediction from video. Table 2 includes the results of the best methods taken from the extensive analysis done in Mathe & Sminchisescu (2015). The table reports also some useful baselines, such as the central bias (CB) and the human accuracy for the task. Note that: 1) CB differs from TCB, since it does not use any training fixations; and 2) the human accuracy is computed in (Mathe & Sminchisescu, 2015) by deriving a saliency map from half of our human subjects and is evaluated with respect to fixations of the remaining ones. Furthermore, Table 2 contrasts the use of static features, motion features and their combination. The last row reports the results obtained with our RMDN model. It is interesting to see that the results obtained with a single type of features (static or motion) have an AUC lower than 0.75, which is even lower than the one obtained by the central bias (0.84). Moreover, the combination reaches the best results when the central bias is combined with engineered features $\mathbf { \left( S F { + } M F { + } C B \right) }$ ). On the other hand, our method outperforms all the methods evaluated in Mathe & Sminchisescu (2015) by a large margin and our results are very close to human performance (the difference is only $3 . 2 \%$ ). In addition to being the best method in Table 2, our method has several advantages: 1) it does not require any hand-engineering of spatiotemporal features, 2) it performs joint training of the LSTM and the saliency predictor, 3) it is very efficient. Specifically, although we cannot estimate the runtime for prior approaches, we believe that our method is much faster than most of the methods reported in Table 2 as these depend on features that are computationally expensive to extract. Our proposed method takes only 0.08s per clip for inference on GPU: 0.07s to compute C3D features and 0.01s to evaluate the RMDN.
+
+Table 2: Saliency prediction comparison against the state-of-the-art on the Hollywood2 dataset. The top-3 best results for each set are taken from (Mathe & Sminchisescu, 2015)   
+
+<table><tr><td rowspan=1 colspan=1>Set</td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>AUC</td></tr><tr><td rowspan=1 colspan=1>Baselines</td><td rowspan=1 colspan=1>UniformCentral Bias (CB)Trained Central Bias (TCB)Human</td><td rowspan=1 colspan=1>0.5000.8400.8720.936</td></tr><tr><td rowspan=1 colspan=1>SF = Static Features</td><td rowspan=1 colspan=1>Color features (Judd et al., 2009)Saliency map (Oliva &amp; Torralba,2001)Horizon det.(Oliva &amp; Torralba,2001)</td><td rowspan=1 colspan=1>0.6440.7020.741</td></tr><tr><td rowspan=1 colspan=1>MF=Motion Features(Mathe &amp; Sminchisescu,2015)</td><td rowspan=1 colspan=1>FlowmagnitudeFlow bimodalityHOG-MBH det.</td><td rowspan=1 colspan=1>0.6260.6370.743</td></tr><tr><td rowspan=1 colspan=1>Combo(Mathe &amp; Sminchisescu,2015)</td><td rowspan=1 colspan=1>SF (Judd et al., 2009)SF+MFSF+MF+CB</td><td rowspan=1 colspan=1>0.7890.8120.871</td></tr><tr><td rowspan=1 colspan=1>OurMethod</td><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>0.904</td></tr></table>
+
+# 4.2 ACTION RECOGNITION
+
+In order to show how saliency can be used for action recognition we carried out a set of experiments covering two scenarios: 1) using the same dataset where the saliency predictor was trained (Hollywood2) and 2) using a never-seen dataset with a different set of actions (UCF101).
+
+The results on Hollywood2 are reported in terms of mean Average Precision (mAP) as done by Mathe & Sminchisescu (2015). Table 3 shows an analysis of 1) the impact of using different feature representations as well as 2) the effect of the saliency map. As in Tran et al. (2015), we experimented with different features, namely CONV5 and FC6, which correspond to the fifth convolutional layer and the first fully-connected representation of C3D, respectively. We also tested two ways to use the saliency maps, called in the second column: “feature” and “clip”. In the feature mode (first row, experiments (2-5)), the convolutional representation is multiplied by the saliency map, after resizing it accordingly. In other words, the saliency weights directly the feature representation, similarly to the work of Sharma et al. (2016). In the clip mode (second and third row, experiments (2-5)), we adopted the model presented in Sec. 3.4, where the saliency maps are used to weight the input video pixels.
+
+The third column of Table 3 (experiment (1)) reports the results using only the original video as input to C3D (referred to as context in Fig. 2). Experiment (2) uses the ground truth saliency maps as soft attention to weight the input of C3D, while in experiment (3) this vector is concatenated with the context features. The last two columns (experiment (4) and (5)) represent the same setup, but in this case we use the saliency maps predicted by our model instead of the ground truth.
+
+Table 3 shows that the results of CONV5 and FC6 are very close when considering the original video (experiment (1)). The table also shows that the feature mode has lower performance compared to the clip mode (experiment (2)). Moreover, the concatenation (experiment (3)) is effective only when visual attention is used to weight pixels rather than features. Based on the poor performance of the features mode, we decided to experiment only with the clip mode in our study with predicted saliency (experiment (4) and (5)). Also, we decided to use FC6 features for the rest of the paper because the representation is more compact and therefore allows to train the classifiers more quickly. We can notice that even in the case of predicted saliency, the concatenation of FC6 context features and those obtained by weighting the input video with soft-attention (experiment (5)) produces a significant improvement over the original CONV5/FC6 features without attention. Furthermore, a pleasant surprise is represented by the the small difference in results between using the predicted saliency (experiment (5)) versus the ground truth maps (experiment (3)): only $0 . 2 7 \%$ for FC6 (last row).
+
+The SVM model complexity for experiment (3) in Table 3 is twice as large as the complexity for (1) and (2) since the feature dimensionality is doubled by construction. The same applies when comparing (5) against (1) and (4). In order to have a more fair comparison, we added PCA dimensionality reduction to experiment (5) in order to match the same feature dimensionality as (1) (and (4)). Although the validation accuracies are very similar, the testing mAP drops from $5 4 . 8 5 \%$ of experiment (5) to $5 1 . 8 2 \%$ of the PCA experiment. This is not surprising, since the extra dimensions provided by the use of the saliency map are not redundant with respect to the context representation (1). Therefore, concatenation seems to be an effective way to make use of the saliency map.
+
+Table 3: Action categorization results in terms of mAP on the Hollywod2 dataset. Analysis of different ways to use the saliency map and comparison between using the ground truth saliency maps versus those predicted by our model.   
+
+<table><tr><td>Saliency</td><td></td><td></td><td colspan="2">Ground Truth</td><td colspan="2">Predicted</td></tr><tr><td>Input</td><td>Saliency Use</td><td>(1) Original</td><td>(2)Weighted</td><td>(3) Concat. (1,2)</td><td>(4)Weighted</td><td>(5)Concat. (1,4)</td></tr><tr><td>CONV5</td><td>Feature</td><td>46.08%</td><td>40.76%</td><td>45.62%</td><td>N/A</td><td>N/A</td></tr><tr><td>CONV5</td><td>Clip</td><td>46.08%</td><td>44.89%</td><td>55.49%</td><td>39.42%</td><td>53.41%</td></tr><tr><td>FC6</td><td>Clip</td><td>47.00%</td><td>41.78%</td><td>55.12%</td><td>39.00%</td><td>54.85%</td></tr></table>
+
+Table 4: Recognition results in terms of mAP for the Hollywood2 dataset. The proposed method (RMDN) is compared to the approaches reported by Mathe & Sminchisescu (2015) (named as central bias and saliency sampling). Note that Mathe & Sminchisescu (2015) and RDMN do not use the same video classification model.   
+
+<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=5>Ground Truth</td><td rowspan=1 colspan=3>Predicted</td></tr><tr><td rowspan=1 colspan=1>Class</td><td rowspan=1 colspan=4>SalSampling</td><td rowspan=1 colspan=1>our RMDN</td><td rowspan=1 colspan=1>Central Bias</td><td rowspan=1 colspan=1>SalSampling</td><td rowspan=1 colspan=1>our RMDN</td></tr><tr><td rowspan=4 colspan=1>AnswerPhoneDriveCarEatFightPerson</td><td rowspan=1 colspan=4>28.1%</td><td rowspan=1 colspan=1>21.8%</td><td rowspan=1 colspan=1>23.3%</td><td rowspan=1 colspan=1>23.7%</td><td rowspan=1 colspan=1>29.8%</td></tr><tr><td rowspan=1 colspan=4>94.8%</td><td rowspan=1 colspan=1>89.2%</td><td rowspan=1 colspan=1>92.4%</td><td rowspan=1 colspan=1>92.8%</td><td rowspan=1 colspan=1>91.6%</td></tr><tr><td rowspan=1 colspan=4>67.3%</td><td rowspan=1 colspan=1>59.4%</td><td rowspan=1 colspan=1>58.6%</td><td rowspan=1 colspan=1>70.0%</td><td rowspan=1 colspan=1>49.1%</td></tr><tr><td rowspan=1 colspan=4>80.6%</td><td rowspan=1 colspan=1>80.9%</td><td rowspan=1 colspan=1>76.3%</td><td rowspan=1 colspan=1>76.1%</td><td rowspan=1 colspan=1>79.2%</td></tr><tr><td rowspan=5 colspan=1>GetOutCarHandShakeHugPersonKissRun</td><td rowspan=2 colspan=4>55.1%27.6%</td><td rowspan=1 colspan=1>78.0%</td><td rowspan=1 colspan=1>49.6%</td><td rowspan=1 colspan=1>54.9%</td><td rowspan=1 colspan=1>76.9%</td></tr><tr><td rowspan=1 colspan=3>27.6%</td><td rowspan=1 colspan=1>58.6%</td><td rowspan=1 colspan=1>26.5%</td><td rowspan=1 colspan=1>27.9%</td><td rowspan=1 colspan=1>47.0%</td></tr><tr><td rowspan=1 colspan=2></td><td></td><td rowspan=1 colspan=1>37.8%</td><td rowspan=1 colspan=1>27.5%</td><td rowspan=1 colspan=1>34.6%</td><td rowspan=1 colspan=1>39.5%</td><td rowspan=1 colspan=1>37.9%</td></tr><tr><td rowspan=2 colspan=4>66.4%85.7%</td><td rowspan=1 colspan=1>66.4%</td><td rowspan=1 colspan=1>52.2%</td><td rowspan=1 colspan=1>62.1%</td><td rowspan=1 colspan=1>61.3%</td><td rowspan=2 colspan=1>51.0%83.2%</td></tr><tr><td rowspan=1 colspan=1>85.5%</td><td rowspan=1 colspan=1>77.8%</td><td rowspan=1 colspan=1>82.2%</td></tr><tr><td rowspan=1 colspan=1>SitDown</td><td rowspan=1 colspan=4>62.5%</td><td rowspan=1 colspan=1>31.8%</td><td rowspan=1 colspan=1>62.1%</td><td rowspan=1 colspan=1>69.0%</td><td rowspan=3 colspan=1>31.4%39.7%41.3%</td></tr><tr><td rowspan=1 colspan=1>SitUp</td><td rowspan=1 colspan=4>30.7%</td><td rowspan=1 colspan=1>38.0%</td><td rowspan=1 colspan=1>20.9%</td><td rowspan=1 colspan=1>29.7%</td></tr><tr><td rowspan=1 colspan=1>StandUp</td><td rowspan=1 colspan=4>58.2%</td><td rowspan=1 colspan=1>37.8%</td><td rowspan=1 colspan=1>61.3%</td><td rowspan=1 colspan=1>63.9%</td></tr><tr><td rowspan=1 colspan=1>Mean</td><td rowspan=1 colspan=4>57.9%</td><td rowspan=1 colspan=1>55.1%</td><td rowspan=1 colspan=1>53.7%</td><td rowspan=1 colspan=1>57.6%</td><td rowspan=1 colspan=1>54.8%</td></tr></table>
+
+Table 4 compares our action categorization results with those presented in Mathe & Sminchisescu (2015). As we did before, we separate experiments that use the ground truth maps and those that use predicted saliency. The results of Table 4 show that the performance our method (second and fifth column) is around $2 \%$ lower than Mathe & Sminchisescu (2015). However this is most likely explained by the differences in the type of features and classifier, and not by the differences in saliency map prediction methods. Indeed, we already established in Table 2 that our proposed saliency map predictor is more accurate than the one proposed in Mathe & Sminchisescu (2015). On the other hand, Mathe & Sminchisescu (2015) use a combination of many different features and a kernel chi-square SVM, while our method uses C3D features with a simple linear SVM classifier. Adding more non-linearities, especially for the concatenation experiment, would probably help. But we consider the experimentation with different types of action recognition features and classifiers out of the scope of this paper.
+
+Finally, we perform an experiment to assess the generalization abilities of the learned saliency model to a different dataset, with classes and videos that have not been seen during its training. To this end, we used the attentional model trained on the Hollywood2 dataset to extract saliency maps on the UCF101 dataset. As saliency ground truth is not available for UCF101, we evaluate performance in terms of action recognition accuracy using the evaluation protocol and splits by Soomro et al. (2012). Table 5 summarizes the results. The proposed method $( \mathrm { C 3 D + R M D N }$ , eight row) corresponds to the concatenation of the original C3D descriptor and the C3D descriptor with the input weighted by the saliency map, as was done in the Hollywood2 experiments. We compare our method with the results obtained using the C3D descriptor computed from the context only (seventh row) and other state-ofthe-art methods (first row through sixth row). A linear SVM trained on C3D features computed from the context already outperforms most of the other methods (first row to forth row). But training the linear SVM on a concatenation of context C3D features and those obtained by reweighting the video input with the RMDN saliency maps (seventh row) leads to a further improvement of $1 . 1 \%$ . This is an impressive result since the RMDN was trained on the separate and small Hollywood2 dataset.
+
+Since we noticed that the saliency maps of RMDN for UCF101 tend to be highly peaked around a single location in each frame, we added the trained central bias (already analyzed in Table 1). This has the effect of diffusing the saliency map with the central bias, thus enlarging the area of attention used by the recognition system. The result of this experiment, which is reported in the last row of Table 5, further improves the accuracy by $1 . 3 \%$ .
+
+Table 5: Action categorization results in terms of 3-fold accuracy on the UCF101 dataset.   
+
+<table><tr><td>Method</td><td>Accuracy</td></tr><tr><td>Imagenet+linear SVM iDT(Wang&amp; Schmid,2013)+BoW+ linear SVM Spatial stream network (Simonyan &amp; Zisserman,2014) LSTM composite model (Srivastava et al., 2015) scLSTM(Song et al., 2016) LSTM(optical flow, images) (Yue-Hei Ng et al., 2015)</td><td>68.8% 76.2% 72.6% 75.8% 84.0% 88.6%</td></tr><tr><td>C3D+linear SVM C3D+RMDN+ linear SVM C3D+RMDN+TCB+ linear SVM</td><td>80.4% 81.5% 82.8%</td></tr></table>
+
+# 5 CONCLUSIONS
+
+In this paper, we proposed a recurrent mixture density network for spatiotemporal visual attention. We showed that our model outperforms state-of-the-art methods for saliency prediction in videos. We have also shown that the saliency maps generated by our model can be leveraged to improve action categorization using a very simple procedure. This suggests that saliency can enrich the original video representation. The runtime overhead to estimate the saliency map is very small: only 0.01s added to the feature extraction time of 0.07s.
+
+As future work, we plan to close the gap between RMDN and action recognition with a joint network. The idea is to have as output of the model both the saliency map at each time and the class of the action for the entire video. This can be combined with the idea of using the saliency map estimated at the previous time to weight the input for the current time. Putting together these two ideas in a single network would result in a joint model for saliency prediction and action recognition.
+
+# 6 ACKNOWLEDGMENTS
+
+We thank Du Tran for helpful discussion about the code of the C3D network and its usage. We are grateful to Stefan Mathe for explaining the format of the eyetracking data and the protocol of the Hollywood2 experiment. This work was funded in part by NSF award CNS-1205521. We gratefully acknowledge NVIDIA for the donation of GPUs used for portions of this work.
+
+# REFERENCES
+
+Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In Proceedings of the International Conference on Learning Representations (ICLR), 2015.
+
+L. Bazzani, N. de Freitas, H. Larochelle, V. Murino, and J-A Ting. Learning attentional policies for object tracking and recognition in video with deep networks. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 937–944, June 2011.
+
+Christopher M Bishop. Mixture density networks. In Technical Report. Aston University, 1994.
+
+A. Borji and L. Itti. State-of-the-art in visual attention modeling. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(1):185–207, Jan 2013. ISSN 0162-8828. doi: 10.1109/ TPAMI.2012.89.
+
+Ali Borji, Dicky N Sihite, and Laurent Itti. Quantitative analysis of human-model agreement in visual saliency modeling: A comparative study. Image Processing, IEEE Transactions on, 22(1): 55–69, 2013.
+
+Neil DB Bruce, Christopher Catton, and Sasa Janjic. A deeper look at saliency: Feature contrast, semantics, and beyond. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 516–524, 2016.
+
+S. Chaabouni, J. Benois-Pineau, and C. Ben Amar. Transfer learning with deep networks for saliency prediction in natural video. In 2016 IEEE International Conference on Image Processing (ICIP), pp. 1604–1608, Sept 2016a.
+
+Souad Chaabouni, Jenny Benois-Pineau, Ofer Hadar, and Chokri Ben Amar. Deep learning for saliency prediction in natural video. CoRR, abs/1604.08010, 2016b.
+
+Jennifer T. Coull. fmri studies of temporal attention: allocating attention within, or towards, time. Cognitive Brain Research, 21(2):216 – 226, 2004. Neuroimaging of Interval Timing.
+
+M. Denil, L. Bazzani, H. Larochelle, and N. de Freitas. Learning where to attend with deep architectures for image tracking. Neural Computation, 2012.
+
+Y. Gitman, M. Erofeev, D. Vatolin, B. Andrey, and F. Alexey. Semiautomatic visual-attention modeling and its application to video compression. In Image Processing (ICIP), 2014 IEEE International Conference on, pp. 1105–1109, Oct 2014. doi: 10.1109/ICIP.2014.7025220.
+
+Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013.
+
+Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. In David Blei and Francis Bach (eds.), Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1462–1471. JMLR Workshop and Conference Proceedings, 2015.
+
+Chenlei Guo, Qi Ma, and Liming Zhang. Spatio-temporal saliency detection using phase spectrum of quaternion fourier transform. In Computer vision and pattern recognition, 2008. cvpr 2008. ieee conference on, pp. 1–8. IEEE, 2008.
+
+Jonathan Harel, Christof Koch, and Pietro Perona. Graph-based visual saliency. In Advances in neural information processing systems, pp. 545–552, 2006.
+
+Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997.
+
+Sayed Hossein Khatoonabadi, Nuno Vasconcelos, Ivan V. Bajic, and Yufeng Shan. How many bits does it take for a stimulus to be salient? In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Xun Huang, Chengyao Shen, Xavier Boix, and Qi Zhao. Salicon: Reducing the semantic gap in saliency prediction by adapting deep neural networks. In The IEEE International Conference on Computer Vision (ICCV), December 2015.
+
+Saumya Jetley, Naila Murray, and Eleonora Vig. End-to-end saliency mapping via probability distribution prediction. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016.
+
+Ming Jiang, Juan Xu, and Qi Zhao. Saliency in crowd. In Computer Vision–ECCV 2014, pp. 17–32. Springer, 2014.
+
+Tilke Judd, Krista Ehinger, Fredo Durand, and Antonio Torralba. Learning to predict where humans ´ look. In Computer Vision, 2009 IEEE 12th international conference on, pp. 2106–2113. IEEE, 2009.
+
+Tilke Judd, Fredo Durand, and Antonio Torralba. A benchmark of computational models of saliency´ to predict human fixations. In MIT Technical Report, 2012.
+
+S. Karthikeyan, Thuyen Ngo, Miguel Eckstein, and B.S. Manjunath. Eye tracking assisted extraction of attentionally important objects from videos. In IEEE International Conference on Computer Vision and Pattern Recognition, Jun 2015.
+
+Matthias Kummerer, Lucas Theis, and Matthias Bethge. Deep gaze I: boosting saliency prediction ¨ with feature maps trained on imagenet. In ICLR, 2015.
+
+Hugo Larochelle and Geoffrey E. Hinton. Learning to combine foveal glimpses with a third-order Boltzmann machine. In Advances in Neural Information Processing Systems 23 (NIPS 2010), pp. 1243–1251, Vancouver, Canada, 2010.
+
+Guanbin Li and Yizhou Yu. Visual saliency based on multiscale deep features. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Nian Liu, Junwei Han, Dingwen Zhang, Shifeng Wen, and Tianming Liu. Predicting eye fixations using convolutional neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, Boston, MA, USA, June 7-12, 2015, pp. 362–370, 2015.
+
+Aravindh Mahendran and Andrea Vedaldi. Salient deconvolutional networks. In European Conference on Computer Vision, pp. 120–135. Springer, 2016.
+
+Marcin Marszałek, Ivan Laptev, and Cordelia Schmid. Actions in context. In IEEE Conference on Computer Vision & Pattern Recognition, 2009.
+
+S. Mathe and C. Sminchisescu. Actions in the eye: Dynamic gaze datasets and learnt saliency models for visual recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 37(7):1408–1424, July 2015. ISSN 0162-8828. doi: 10.1109/TPAMI.2014.2366154.
+
+Thomas Mauthner, Horst Possegger, Georg Waltner, and Horst Bischof. Encoding based saliency detection for videos and images. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in Neural Information Processing Systems, pp. 2204–2212, 2014.
+
+Aude Oliva and Antonio Torralba. Modeling the shape of the scene: A holistic representation of the spatial envelope. Int. J. Comput. Vision, 42(3):145–175, May 2001.
+
+Junting Pan and Xavier Giro i Nieto. End-to-end convolutional network for saliency prediction. ´ CoRR, abs/1507.01422, 2015.
+
+Dmitry Rudoy, Dan B. Goldman, Eli Shechtman, and Lihi Zelnik-Manor. Learning video saliency from human gaze using candidate selection. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2013.
+
+Michael Sapienza, Fabio Cuzzolin, and Philip HS Torr. Learning discriminative space–time action parts from weakly labelled videos. International Journal of Computer Vision, 110(1):30–47, 2014.
+
+Pierre Sermanet, Andrea Frome, and Esteban Real. Attention for fine-grained categorization. CoRR, abs/1412.7054, 2014.
+
+Shikhar Sharma, Ryan Kiros, and Ruslan Salakhutdinov. Action recognition using visual attention. In ICLR workshops, 2016.
+
+K. Simonyan, A. Vedaldi, and A. Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In Proceedings of the International Conference on Learning Representations (ICLR), 2014.
+
+Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In Advances in Neural Information Processing Systems, pp. 568–576, 2014.
+
+Jingkuan Song, Heng Shen, et al. Beyond frame-level cnn: Saliency-aware 3d cnn with lstm for video action recognition. IEEE Signal Processing Letters, 2016.
+
+Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012.
+
+Nitish Srivastava, Elman Mansimov, and Ruslan Salakhudinov. Unsupervised learning of video representations using lstms. In David Blei and Francis Bach (eds.), Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 843–852. JMLR Workshop and Conference Proceedings, 2015.
+
+Cristian Sminchisescu Stefan Mathe. Action from still image dataset and inverse optimal control to learn task specific visual scanpaths. In Advances in Neural Information Processing Systems, 2013.
+
+Du Tran, Lubomir Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4489–4497, 2015.
+
+Eleonora Vig, Michael Dorr, and David Cox. Space-variant descriptor sampling for action recognition based on saliency and eye movements. In European conference on computer vision, pp. 84–97. Springer, 2012.
+
+Heng Wang and Cordelia Schmid. Action recognition with improved trajectories. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3551–3558, 2013.
+
+Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 2048–2057, 2015.
+
+Li Yao, Atousa Torabi, Kyunghyun Cho, Nicolas Ballas, Christopher Pal, Hugo Larochelle, and Aaron Courville. Describing Videos by Exploiting Temporal Structure. In IEEE International Conference on Computer Vision (ICCV), pp. 4507–4515, 2015.
+
+Donggeun Yoo, Sunggyun Park, Joon-Young Lee, Anthony S. Paek, and In So Kweon. Attentionnet: Aggregating weak directions for accurate object detection. In The IEEE International Conference on Computer Vision (ICCV), December 2015.
+
+Y. Yu, G. K. I. Mann, and R. G. Gosine. An object-based visual attention model for robotic applications. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 40(5): 1398–1412, Oct 2010. ISSN 1083-4419. doi: 10.1109/TSMCB.2009.2038895.
+
+Joe Yue-Hei $\mathrm { N g }$ , Matthew Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4694–4702, 2015.
+
+Yun Zhai and Mubarak Shah. Visual attention detection in video sequences using spatiotemporal cues. In Proceedings of the 14th annual ACM international conference on Multimedia, pp. 815– 824. ACM, 2006.
+
+Jiaping Zhao, Christian Siagian, and Laurent Itti. Fixation bank: Learning to reweight fixation candidates. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015.
+
+Yin Zheng, Yu-Jin Zhang, and Hugo Larochelle. A Neural Autoregressive Approach to Attentionbased Recognition. International Journal of Computer Vision, 113(1):67–79, 2015.
+
+![](images/d470b16271fd4e81b71930ff5c6a7c114bb58481fc13642ea4fa49701e22f715.jpg)  
+Figure 2: Model for action recognition. The original clip of $K$ frames is fed into a 3D convolutional network. The same clip is then weighted by the predicted saliency map estimated by our RMDN and then fed into the 3D convolutional network. The final clip-level representation is then concatenated. All the clips of a video are merged using pooling and then a linear classifier can be trained.
+
+# A SALIENCY FOR CLASSIFICATION
+
+The proposed model for recognition is presented in Fig. 2. At each time $t$ , we extract two representations: the context branch is given by the C3D representation of the original clip, while the soft attentional branch is given by the C3D representation of the input clip weighted by the saliency map. The two representations are then concatenated at the clip level and max-pooled over the video to obtain the final video-level descriptor. This video-level representation is then used as input to train the video classifier which is a linear SVM in our experiments.
+
+In our experiments, we also evaluated the option of weighting the convolutional feature map $\mathbf { x } _ { t }$ instead of the input, as for example done by Sharma et al. (2016). However, we will see that soft-masking the input gives higher accuracy, probably because applying C3D’s non-linear transformation after the soft-weighting produces a representation that is less redundant with the original (non-masked) C3D representation.
+
+# B IMPLEMENTATION DETAILS
+
+We used the pretrained C3D network (Tran et al., 2015) as feature representation which is the input of the LSTM network. The convolutional layer before the fully-connected layers is used for saliency prediction, while the last fully-connected layer before the softmax is used for classification, since Tran et al. (2015) showed to obtain the best performance.
+
+The training of the RMDN is performed using RMSprop with adaptive learning rate and gradient clipping. We start from a learning rate of 0.0003 and after 8 epochs it is reduced at each epoch with a decay factor of 0.95. The gradient is clipped with a threshold of 20. Dropout with a ratio of 0.5 is applied only on the hidden layer of the LSTM network before the MDN. We trained for 40 epochs, but training is stopped if there is no significative improvement of the loss. During training, temporal data augmentation is performed by clipping the videos to shorter videos of length 65 frames (which corresponds to $5 0 \mathrm { C } 3 \mathrm { D }$ descriptors since it needs a buffer of 16 frames for the first descriptor). The number of components of the GMM $C$ is fixed to 20 for all the experiments. All the experiments were carried out using an NVIDIA Tesla K40 card.
+
+After extracting the saliency maps and the feature representations on GPU, our recognition experiments were performed on CPU using a linear SVM. In order to compute the video-level representation, we performed max pooling of the clip-level representations of the video. For all the experiments, we used $2 0 \%$ of the training data as validation set to find the regularization parameter of the SVM. We searched the parameter space on a grid between $1 0 ^ { - 9 }$ to $1 0 ^ { 3 }$ with a step of $1 0 ^ { \frac { 1 } { 2 } }$ . Finally, we retrain the SVM on all the training set (including the validation set) using the best cross-validated parameter.

parse/train/SJRpRfKxx/SJRpRfKxx_content_list.json

@@ -0,0 +1,1655 @@
+[
+    {
+        "type": "text",
+        "text": "RECURRENT MIXTURE DENSITY NETWORK FOR SPATIOTEMPORAL VISUAL ATTENTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            98,
+            699,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Loris Bazzani∗   \nAmazon   \nBerlin, Germany   \nbazzanil@amazon.com   \nHugo Larochelle†   \nDepartement d’informatique ´   \nUniversite de Sherbrooke´   \nhugo.larochelle@usherbrooke.ca   \nLorenzo Torresani   \nDepartment of Computer Science   \nDartmouth College   \nlt@dartmouth.edu ",
+        "bbox": [
+            183,
+            170,
+            372,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            517,
+            169,
+            813,
+            226
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            184,
+            247,
+            405,
+            303
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            339,
+            544,
+            354
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In many computer vision tasks, the relevant information to solve the problem at hand is mixed with irrelevant, distracting information. This has motivated researchers to design attentional models that can dynamically focus on parts of images or videos that are salient, e.g., by down-weighting irrelevant pixels. In this work, we propose a spatiotemporal attentional model that learns where to look in a video directly from human fixation data. We model visual attention with a mixture of Gaussians at each frame. This distribution is used to express the probability of saliency for each pixel. Time consistency in videos is modeled hierarchically by: 1) deep 3D convolutional features to represent spatial and short-term time relations at clip level and 2) a long short-term memory network on top that aggregates the clip-level representation of sequential clips and therefore expands the temporal domain from few frames to seconds. The parameters of the proposed model are optimized via maximum likelihood estimation using human fixations as training data, without knowledge of the action in each video. Our experiments on Hollywood2 show state-of-the-art performance on saliency prediction for video. We also show that our attentional model trained on Hollywood2 generalizes well to UCF101 and it can be leveraged to improve action classification accuracy on both datasets. ",
+        "bbox": [
+            233,
+            372,
+            764,
+            621
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            650,
+            336,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Attentional modeling and saliency prediction in images has been an active research topic in computer vision over the last decade. Interest in attentional models is primarily motivated by their ability to eliminate or down-weight pixels that are not important for the task at hand, as for example shown in prior work using visual attention for image recognition and caption generation (Sermanet et al., 2014; Xu et al., 2015; Mnih et al., 2014). Integrating visual attention in an image analysis model can potentially lead to improved overall accuracy, as the system can focus on the most salient regions in the photo without being disturbed by irrelevant information. ",
+        "bbox": [
+            174,
+            683,
+            825,
+            780
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Recently, we have witnessed a shift of trend from image saliency prediction (Borji & Itti, 2013) to the modeling of saliency in videos (Rudoy et al., 2013). Since human fixation patterns are strongly correlated over time (Coull, 2004), it appears critical to model the relations between saliency maps of consecutive frames. In this scenario, attention can be defined as a spatiotemporal volume, where each saliency map (one for each frame) depends on the frames at the previous times. The saliency map can be interpreted as a probability distribution over pixels and the actual fixation patterns can be generated by sampling from the the map. ",
+        "bbox": [
+            174,
+            787,
+            825,
+            885
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Going from images to videos is not straightforward, since videos bring up many challenges. First of all, videos have an additional dimension (time), compared to images. This causes a dramatic growth in the number of pixels to be processed and poses a significantly higher computational cost for analysis. At the same time, there are strong redundancies present in such data, which implies that visual attention may be particularly beneficial for the video setting. For example, typically the objects or people in a video do not change significantly in appearance over time. Yet, for analysis tasks such as action recognition (Wang & Schmid, 2013) or video description (Yao et al., 2015), it is imperative to properly model the dynamical properties of these objects in the video. This suggests that, in order to identify spatiotemporal volumes that are salient for video analysis, an attentional model must take into account high-level image semantics as well as the history of past fixations. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            242
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In order to cope with these challenges, we propose an efficient spatiotemporal attentional model (see Fig. 1) that leverages deep 3D convolutional features (Tran et al., 2015) as semantic, spatiotemporal representation of short clips in the video. This clip-level representation is then aggregated by a Long Short-Term Memory (LSTM) network (Hochreiter & Schmidhuber, 1997), that expands the temporal range of analysis from few frames to seconds. The LSTM model connects into a Mixture Density Network (MDN) (Bishop, 1994) that at each frame outputs the parameters of a Gaussian mixture model expressing the saliency map. We refer to this model as Recurrent Mixture Density Network (RMDN). RMDN is trained via maximum likelihood estimation using human fixations as training data, without knowledge of the actions in the videos. ",
+        "bbox": [
+            174,
+            250,
+            825,
+            375
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The potential applications of automatic saliency map prediction from videos are many. They include attention-based video compression (Gitman et al., 2014), visual attention for robots (Yu et al., 2010), crowd analysis for video surveillance (Jiang et al., 2014), salient object detection (Li & Yu, 2015; Karthikeyan et al., 2015) and activity recognition (Vig et al., 2012; Sapienza et al., 2014). In this work we focus on a study of how visual attention may improve action recognition by leveraging the saliency map generated by RMDN for video classification. The idea is akin to soft attention and consists in re-weighting the pixel values of the input video by the estimated saliency map. Despite its simplicity, we show that the combination of features extracted from this modified version of the video and those computed from the original input lead to a significant improvement in action recognition, compared to a model that does not use attention. ",
+        "bbox": [
+            174,
+            382,
+            825,
+            520
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The primary contribution of this work is a spatiotemporal saliency estimation network optimized to reproduce human fixations. The proposed approach offers several advantages: 1) the model can be trained without having to engineer spatiotemporal features; 2) RMDN is directly trained on examples of human fixations and thus learns to mimic human visual attention; 3) prediction of the saliency map is very fast (it takes 0.08s per 16-frame clip on a GPU); 4) the method outperforms the state-of-the-art (Mathe & Sminchisescu, 2015) in saliency accuracy; 5) our predicted saliency maps lead to to improvements in action classification accuracy. ",
+        "bbox": [
+            174,
+            527,
+            825,
+            625
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            647,
+            344,
+            664
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Broadly speaking, the literature on attentional models can be split into two categories: task-agnostic approaches which model the bottom-up, free-viewing properties of attention, and task-specific methods which model its top-down, task-driven properties. Researchers have devoted many years to create datasets, collecting human fixations and proposing solutions for biologically-plausible saliency estimators, built using low-level cues such as edge detectors and color filters (e.g. see Borji et al. (2013); Judd et al. (2009); Harel et al. (2006) for recent examples). We refer to Borji & Itti (2013) and Bruce et al. (2016) for an interesting analysis and comparison of existing methods. Most of the techniques in the literature are focused on extracting features in a bottom-up and/or top-down manner and use them to estimate the saliency map. In this context, motion features are introduced when extending saliency methods from images to videos (Guo et al., 2008; Zhao et al., 2015; Zhai & Shah, 2006). However, there is no explicit modeling of the temporal dimension that can capture long-term relations. In fact, motion features (e.g., optical flow) describe short-term associations at the temporal scale of only a few consecutive frames. ",
+        "bbox": [
+            174,
+            680,
+            825,
+            861
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Prior approaches can also be categorized into soft-attentional versus hard-attentional models. Softattentional models use the predicted saliency maps to down-weight pixels that are not relevant or salient, e.g., Song et al. (2016). Specifically deep networks have been used in this context to assign a weight to each pixel in order to extract “glimpses” from images (Xu et al., 2015; Gregor et al., 2015) ",
+        "bbox": [
+            176,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "or videos (Yao et al., 2015) in the form of weighted pixel averages. One strength of such approaches is that they can backpropagate through the attentional component and tune it in the context of its use in a deep network. Other work has been geared towards learning hard-attentional models, which explicitly ignore and discard parts of the input (Larochelle & Hinton, 2010; Bazzani et al., 2011; Denil et al., 2012; Mnih et al., 2014; Xu et al., 2015; Sermanet et al., 2014; Ba et al., 2015; Yoo et al., 2015; Zheng et al., 2015), thus providing significant computational savings. Unfortunately, such models are often hard to train because they rely on reinforcement learning techniques to generate the image/video locations during training. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "All of the aforementioned prior work attempts to learn attentional models indirectly rather than from explicit information of where humans look. Recent work (Mauthner et al., 2015; Hossein Khatoonabadi et al., 2015; Mathe & Sminchisescu, 2015; Stefan Mathe, 2013; Kummerer et al., 2015; Rudoy ¨ et al., 2013) has shown that it may be possible to accurately reproduce gazing patterns of human subjects attending to images and videos. However, these prior approaches rely on hand-crafted features to estimate the saliency maps. Attempts at removing hand-engineering of features are represented by Jetley et al. (2016); Huang et al. (2015); Kummerer et al. (2015) where networks pre-trained for ¨ object recognition were subsequently finetuned using saliency-based loss functions for images. Pan & i Nieto (2015) followed the same principle but without using any pre-trained network for initialization. Liu et al. (2015) proposed a multi-scale architecture for saliency prediction, and Li & Yu (2015) added a refinement step in order to enforce spatial coherence of the output. Simonyan et al. (2014) and Mahendran & Vedaldi (2016) proposed to reverse deep networks using deconvolutions for visualization and to estimate image saliency. However, these methods estimate saliency from still images and do not consider the temporal aspect of video. Chaabouni et al. (2016a;b) trained a ConvNet for saliency prediction on optical flow features and individual frames. However the model uses only the very short-term temporal relations of two consecutive frames. ",
+        "bbox": [
+            173,
+            222,
+            825,
+            444
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we explore the following question: can deep networks be trained to reliably predict spatiotemporal attentional patterns, specifically in such a way that these predictions can be leveraged successfully by a recognition system? To our knowledge, our work distinguishes itself from the aforementioned literature by being the first application of deep networks to the prediction of spatiotemporal human saliency in videos. ",
+        "bbox": [
+            174,
+            450,
+            823,
+            520
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 PROPOSED MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            542,
+            362,
+            559
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We start with a high-level description of our attentional model. We then formalize it in Sec. 3.1, and describe its training in Sec. 3.2. Sec. 3.3 reports how prediction is efficiently carried out at test time. Sec. 3.4 describes how to leverage the predicted saliency map to improve action recognition. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The proposed RMDN model for saliency estimation is depicted in Fig. 1. At time $t$ , the input of the model is a sequence of the last $K = 1 6$ frames, i.e., from time $t - K + 1$ to current time $t$ . We refer to this sequence as the input “clip.” The first part of the model (Fig. 1, blue layers above the input clip) consists of a 3D convolutional network that provides a feature representation of the clip. Our choice of a clip-based representation rather than a single-frame descriptor is motivated by the fact that these features allow us to explicitly capture short-term information that is then aggregated for long-term spatiotemporal visual attention by RMDN. Furthermore, there is recently growing evidence (Tran et al., 2015; Srivastava et al., 2015; Yue-Hei $\\mathrm { N g }$ et al., 2015) that by modeling the temporal information it is possible to obtain improved performances in high-level video analysis tasks, such as action recognition. For the computation of spatiotemporal features from the input clip, we use the “C3D” architecture proposed by Tran et al. (2015), which has been shown to provide competitive results on video recognition tasks across different datasets. The C3D architecture is defined as: C64-P-C128-P-C256-C256-P-C512-C512-P-C512-C512-P-FC4096-FC4096-softmax, where C is a 3D convolutional layer, P is the pooling layer, FC is a fully-connected layer, and the number specifies the number of kernels of the layer (e.g. C64 has 64 kernels). For the details about the size and stride of the convolutional and pooling kernels, we refer to (Tran et al., 2015). ",
+        "bbox": [
+            174,
+            625,
+            825,
+            847
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The convolutional network has access to a limited window of the video since it uses a fixed-size clip of 16 frames as input. In order to empower the visual attention model with the ability to take into account longer temporal extents, we need a mechanism that performs temporal aggregation of past clip-level signals. To this end, we propose to connect the internal representation of the C3D model to a recurrent neural network, as shown in Fig. 1 (green module). The aim of the temporal connections of the recurrent neural network is to propagate the clip-level features through time via memory units that can capture long-term dependencies. Our model uses LSTMs (Hochreiter & Schmidhuber, 1997) as memory blocks. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/7ce9041d8c9165e1166292f75ff66cb6039f8b1a93f4f581dac38779311070d9.jpg",
+        "image_caption": [
+            "Figure 1: Proposed recurrent mixture density network for saliency prediction. The input clip of $K$ frames is fed into a 3D convolutional network (in blue), whose output becomes the input of a long short-term memory (LSTM) network (in green). Finally, a linear layer projects the LSTM representation to the parameters of a Gaussian mixture model, which describes the saliency map. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            253,
+            111,
+            709,
+            380
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            501,
+            825,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The saliency map at each time $t$ is expressed in terms of a Gaussian Mixture Model (GMM) with $C$ components. We denote its parameters with $\\{ ( \\mu ^ { c } , \\pi ^ { c } , \\Sigma ^ { c } ) \\} _ { c = 1 } ^ { C }$ , where $\\mu ^ { c }$ , $\\pi ^ { c }$ and $\\Sigma ^ { c }$ are the mean, the mixture coefficient and the covariance of the $c$ -th Gaussian component, respectively. The LSTM directly outputs these parameters (see details below). The resulting network is known as a Mixture Density Network (MDN) (Bishop, 1994; Graves, 2013). ",
+        "bbox": [
+            174,
+            550,
+            825,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Since the model is recurrent, there is a direct connection between the inner representation of the LSTM at time $t$ and the one at time $t + 1$ . This favors temporal consistency between the saliency maps at adjacent times. ",
+        "bbox": [
+            176,
+            627,
+            821,
+            670
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 FORMALIZATION OF THE MODEL ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            709,
+            444,
+            724
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let con $\\mathcal { D } = \\{ ( \\mathbf { v } ^ { i } , \\mathbf { a } ^ { i } ) \\} _ { i = 1 } ^ { N }$ be a dataset of videosrally overlapping clips d human fixations pairs. (i.e., sampled with stride $\\mathbf { v } ^ { i } = ( \\mathbf { c } _ { t } ^ { i } ) _ { t = 0 } ^ { T _ { i } - 1 }$ $T _ { i }$ $\\mathbf { c } _ { t } ^ { i }$ $\\mathbf { a } ^ { i } = ( a _ { t } ^ { i } ) _ { t = 0 } ^ { T _ { i } - 1 }$ the sequence of ground-truth fixations for the $i$ -th video aligned with the clips. Since we use C3D to represent each clip, $\\mathbf { c } _ { t } ^ { i }$ has a fixed length of $K = 1 6$ frames and $t = 0$ means that the first $K$ frames t are used to build the 0-th clip. The fixations $a _ { t } ^ { i } = \\{ a _ { t , j } ^ { i } \\} _ { j = 1 } ^ { A }$ are a set of $( x , y )$ image positions that are normalized to $[ 0 , 1 ]$ in order to deal with videos of different resolutions. The number of fixations vary from frame to frame in general, but in our experiments we control it via subsampling in order to obtain for each frame a set of fixed size $A$ . ",
+        "bbox": [
+            173,
+            743,
+            825,
+            861
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathbf { x } _ { t } = \\mathtt { C } 3 \\mathtt { D } ( \\mathbf { c } _ { t } )$ be the internal representation of C3D for an input clip $\\mathbf { c } _ { t }$ . In our model we use the last convolutional layer, before the fully-connected layers. We choose a convolutional layer instead of a fully-connected layer because the latter discards spatial information, which is crucial to estimate a spatially-variant saliency map over the image. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The LSTM network (Hochreiter & Schmidhuber, 1997) is defined as follows: ",
+        "bbox": [
+            173,
+            103,
+            681,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/15e7082f2f7256e77ca21bc29efc04d3674731af40cd4bb92931ebd4c5c573cb.jpg",
+        "text": "$$\n\\begin{array} { l l } { { f _ { t } = \\sigma ( W _ { f } \\cdot [ h _ { t - 1 } , { \\bf x } _ { t } ] + b _ { f } ) , \\quad \\quad \\quad } } & { { i _ { t } = \\sigma ( W _ { i } \\cdot [ h _ { t - 1 } , { \\bf x } _ { t } ] + b _ { i } ) \\quad \\quad } } \\\\ { { o _ { t } = \\sigma ( W _ { o } \\cdot [ h _ { t - 1 } , { \\bf x } _ { t } ] + b _ { o } ) , \\quad \\quad \\quad } } & { { \\tilde { C } _ { t } = \\operatorname { t a n h } \\left( W _ { C } \\cdot [ h _ { t - 1 } , { \\bf x } _ { t } ] + b _ { C } \\right) } } \\\\ { { C _ { t } = f _ { t } * C _ { t - 1 } + i _ { t } * \\tilde { C } _ { t } , \\quad \\quad \\quad } } & { { h _ { t } = o _ { t } * \\operatorname { t a n h } \\left( C _ { t } \\right) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            245,
+            122,
+            753,
+            184
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $f _ { t } , i _ { t } , o _ { t } , C _ { t }$ and $h _ { t }$ are the forget gate, the input gate, the output gate, the memory cell, and the hidden representation, respectively. The learning parameters that need to be estimated during the training phase are $W _ { z }$ and $b _ { z }$ ,where $z \\in \\{ f , i , o , C \\}$ . ",
+        "bbox": [
+            174,
+            188,
+            823,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The MDN (Graves, 2013; Bishop, 1994) takes its inputs from the hidden representation of the LSTM network. Since the output space is 2D (the space of image locations), we can reparametrize the model as $\\{ ( \\mu _ { t } ^ { c } , \\pi _ { t } ^ { c } , \\sigma _ { t } ^ { c } , \\bar { \\rho _ { t } ^ { c } } ) \\} _ { c = 1 } ^ { C ^ { - } }$ , where $\\mu _ { t } ^ { c }$ , $\\pi _ { t } ^ { c }$ , $\\sigma _ { t } ^ { c }$ and $\\rho _ { t } ^ { c }$ are the 2D mean position, the weight, the 2D variance and the correlation of the $c$ -th Gaussian component, respectively. The MDN is therefore defined as follows: ",
+        "bbox": [
+            173,
+            236,
+            825,
+            306
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/82f9d71b6374ae7219c4a0b629799f07fd11170ea6545cba94ef7adc88a494ca.jpg",
+        "text": "$$\ny _ { t } = \\{ ( \\tilde { \\mu } _ { t } ^ { c } , \\tilde { \\pi } _ { t } ^ { c } , \\tilde { \\sigma } _ { t } ^ { c } , \\tilde { \\rho } _ { t } ^ { c } ) \\} _ { c = 1 } ^ { C } = W _ { y } \\cdot h _ { t } + b _ { y }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            310,
+            642,
+            330
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $W _ { y }$ and $b _ { y }$ are the parameters of the linear layer and $h _ { t }$ is the hidden representation of the LSTM network. The parameters of the GMM in Eq. 4 are normalized as follows in order to obtain a valid probability distribution: ",
+        "bbox": [
+            174,
+            335,
+            825,
+            377
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef70182d9723313832a102fc9dafeb1f75422f0e68b0ba7f208114eb44dd94a9.jpg",
+        "text": "$$\n\\mu _ { t } ^ { c } = \\tilde { \\mu } _ { t } ^ { c } , \\quad \\pi _ { t } ^ { c } = \\frac { \\exp ( \\tilde { \\pi } _ { t } ^ { c } ) } { \\sum _ { i = 1 } ^ { C } \\exp ( \\tilde { \\pi } _ { t } ^ { i } ) } , \\quad \\sigma _ { t } ^ { c } = \\exp ( \\tilde { \\sigma } _ { t } ^ { c } ) , \\quad \\rho _ { t } ^ { c } = \\operatorname { t a n h } \\big ( \\tilde { \\rho } _ { t } ^ { c } \\big ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            267,
+            382,
+            730,
+            421
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The composition of the LSTM and the MDN results in the RMDN. ",
+        "bbox": [
+            174,
+            424,
+            612,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 TRAINING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            287,
+            469
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The proposed model can be trained by optimizing the log-likelihood of the training ground truth fixations, $\\mathbf { a } ^ { i }$ , under the GMM. The loss function for the $i$ -th video, $\\mathbf { v } ^ { i }$ , is defined as the negative log-likelihood of the fixations under the GMM, as follows: ",
+        "bbox": [
+            174,
+            481,
+            825,
+            523
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/52bc653989912bdf3a3e4aa1b72e50882b61b7f068e1a50ca9b507af322162d1.jpg",
+        "text": "$$\nL ( { \\mathbf v } ^ { i } , \\mathbf { a } ^ { i } ) = \\sum _ { t = 0 } ^ { T _ { i } - 1 } \\sum _ { j = 1 } ^ { A } - \\log \\left( \\sum _ { c = 1 } ^ { C } \\pi _ { t } ^ { c } { \\mathcal N } ( a _ { t , j } ^ { i } ; \\mu _ { t } ^ { c } , \\sigma _ { t } ^ { c } , \\rho _ { t } ^ { c } ) \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            529,
+            686,
+            574
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { N }$ is the Gaussian distribution. Note that the parameters of the Gaussian components depend on the input video $\\mathbf { v } _ { i }$ , but we do not make this explicit in the equation in order to keep notation simple. ",
+        "bbox": [
+            176,
+            579,
+            823,
+            622
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The log-likelihood of the RMDN is optimized using backpropagation through time, since it is a composition of continuous functions (e.g. linear transformations and element-wise non-linearities) and the LSTM, for which we can compute the gradients. In particular, we refer to the paper of Graves (2013) for the derivation of the gradients for the MDN using the loss function of Eq. 6. In practice, due to the limited training data, we freeze the layers of the C3D network to the values pretrained by Tran et al. (2015) for action recognition. This implies that the low-level representation $\\mathbf { x } _ { t }$ is fixed. We jointly train the LSTM and MDN from randomly initialized parameters. ",
+        "bbox": [
+            173,
+            627,
+            825,
+            727
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            742,
+            302,
+            757
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The inference stage is straightforward by following the equations of Sec. 3.1. At a given time $t$ , the clip from time $t - K + 1$ to $t$ is fed into the C3D network to produce the representation $\\mathbf { x } _ { t }$ . This vector is passed to the LSTM (Eqs. 1, 2, and 3) whose hidden representation is passed to the MDN, which outputs the GMM parameters (Eqs. 4 and 5). In order to generate the final saliency map, we compute the probability of each pixel position under the GMM model. We normalize the probability map to sum up to 1 over the image pixels in order to produce a normalized saliency map. ",
+        "bbox": [
+            174,
+            768,
+            825,
+            853
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.4 SALIENCY FOR CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            869,
+            439,
+            883
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the task of video classification, we generate a modified version of the video by using a softattentional mechanism: the idea is to weight each pixel value by the estimated saliency at that position. This operation effectively down-weights regions that are deemed not salient. The intuition is that then the classifier will be able to focus on the parts of the frame which are most relevant without being distracted by the non-salient regions (see Fig. 2 in Appendix A). ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "At each time $t$ , we extract two representations: the “context” branch is given by the C3D representation of the original clip, while the “soft attentional” branch is given by the C3D representation of the input clip weighted by the saliency map. The rationale is that the context branch considers the global evolution of the activity in the video while the soft attentional branch is focused on the most-salient local evolution of the activity. The two representations are then concatenated at the clip level and max-pooled over the video to obtain the final video-level descriptor. This video-level representation is then used as input to train the video classifier, which is a linear SVM in all our experiments. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            276,
+            326,
+            291
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we evaluate the proposed method for both saliency prediction and action recognition on two challenging datasets: Hollywood2 (Marszałek et al., 2009) and UCF101 (Soomro et al., 2012). Section 4.1 reports a quantitative analysis for the task of saliency prediction. Section 4.2 shows the results for the action recognition task in two scenarios: 1) using the same dataset that was used to train the saliency predictor and 2) applying the pretrained attentional model to a neverseen dataset and a different set of actions. We reported the implementation details in Appendix B. We invite the reader to watch the qualitative results of the proposed method in the form of a video available at https://youtu.be/aXOwc17nx_s. ",
+        "bbox": [
+            174,
+            309,
+            825,
+            421
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 SALIENCY PREDICTION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            443,
+            379,
+            458
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The proposed model is trained using human fixation data. Few datasets provide both human fixations and class labels, which we need for the action recognition experiment discussed in the next section. Therefore, we used the Hollywood2 dataset, which was augmented with eye tracking data by Mathe & Sminchisescu (2015). We follow the same evaluation protocol (i.e., same training/test splits) of Mathe & Sminchisescu (2015) and their validation procedure to compute the final results in order to compare with their work. Mathe & Sminchisescu (2015) generate the ground truth saliency from a binary fixation map where the only non-zero values are at fixations points. The final saliency map is produced by convolving the binary map with an isotropic Gaussian filter with standard deviation $\\sigma$ and then adding to it a uniform distribution with probability parameter $p$ . As in Mathe & Sminchisescu (2015), the values of these two parameters are chosen from $\\sigma \\in \\{ 1 . 5 , 3 . 0 \\}$ and $p \\in \\{ 0 . 2 5 , 0 . 5 \\}$ via hold-out validation. We use a validation set consisting of $2 0 \\%$ of the training set. We use the remaining $8 0 \\%$ of the training data to learn our models, and use the hold-out validation set to choose the hyperpameters of our model. ",
+        "bbox": [
+            174,
+            470,
+            825,
+            651
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We evaluate all models on the test set, using popular metrics proposed in the literature of saliency map prediction for still images (Judd et al., 2012; Borji et al., 2013), such as Area Under the ROC Curve (AUC), Normalized Scanpath Saliency (NSS), linear Correlation Coefficient (CC) and the Similarity score (Sim). We refer to the papers of Judd et al. (2012) and Borji et al. (2013) for their detailed description. ",
+        "bbox": [
+            174,
+            659,
+            823,
+            728
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 1 shows results achieved with different variants of our model and a simple baseline method, which we refer to as Trained Central Bias (TCB). The TCB model is a single GMM trained using the fixations of all the videos in the training sets. TCB predicts the same saliency map for each testing frame, thus it discards completely the temporal information and the image input. This experiment shows that all versions of our RMDN consistently outperform TCB under all metrics, even when using a smaller number of fixations per frame during training. ",
+        "bbox": [
+            174,
+            734,
+            825,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The different variants of RMDN in Table 1 explore the following design choices in our model: 1) the impact of using LSTM hidden units as opposed to regular RNN units (second and third row) and 2) the number of fixations per frame used for training (third and fourth row). These experiments show that LSTM (third row) is better than an RNN (second row) in terms of AUC and NSS, but in order to have better CC and Sim we need to use more fixations per frame (fourth row). This is intuitive: since the LSTM has many more parameters than the RNN, it needs more training data to be properly optimized. ",
+        "bbox": [
+            174,
+            825,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The last row in Table 1 shows the results obtained by retraining our model using the full training set of Mathe & Sminchisescu (2015) instead of just the $8 0 \\%$ subset. For this case (RMDN full) we used the hyper-parameter values selected via hold out-validation for the experiment in the fourth row. This gives the best result for saliency prediction reported in our work and it is the model we used for all the subsequent experiments described below. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "All of the experiments reported in Table 1 were obtained using $C = 2 0$ components in the GMM. We have also studied how the accuracy varies by reducing the value of $C$ . For example, using the RMDN variant of row 5 in Table 1 but with $C = 1 0$ components (instead of 20), the performance does not change dramatically, yielding $\\mathrm { A U C } = \\mathrm { 0 . 8 9 6 6 }$ and $\\mathrm { N S S } { = 2 . 4 3 9 2 }$ . On the other hand, the AUC and the NSS decrease considerably, by $1 . 3 \\%$ and 0.3 points respectively, when using only $C = 2$ components $( \\mathrm { A U C } = 0 . 8 8 3 6$ and $\\mathrm { N S S } = 2 . 1 3 8 5$ ). Based on this analysis, in all our subsequent experiments we used $C = 2 0$ as we noticed that our approach implements automatically a sort of Occam’s razor, setting the weights $\\pi _ { c }$ of many components close to zero when necessary. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            292
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We have also carried out a few side experiments and discovered that using the fully-connected features of C3D instead of the convolutional representation gives results that are at least $1 . 5 \\%$ lower in terms of AUC. Moreover, we tried to finetune the C3D network for action categorization on Hollywood2. However we did not obtain any significant improvement, confirming the findings of Tran et al. (2015): the C3D representation is already general enough to perform effectively on different action recognition tasks and fine-tuning the model on smaller-scale datasets (such as Hollywood2) does not seem beneficial. We also experimented with deep LSTMs, but we obtained an insignificant improvement of performance. For this reason and also because deep LSTMs have more parameters and are more computationally expensive to train, we chose to use a shallow one-layer LSTM. Finally, we run the ablation study where the recurrent link between time $t - 1$ and $t$ of the RMDN is removed: the results in terms of AUC are $1 . 2 \\%$ and $2 . 4 \\%$ lower with respect to the RMDN which uses RNN (second row of Table 1) and LSTM (third row of Table 1), respectively. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            465
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e9918e25f6dd5e422ac4817b18b2c03ac6a018318446c47a8e6f634b83632df3.jpg",
+        "table_caption": [
+            "Table 1: Accuracy of saliency prediction for the Trained Central Bias baseline and different variants of our RMDN model in terms of AUC, NSS, CC and Similarity. Training and testing are performed on disjoint splits of the Hollywood2 dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>Net(#units)</td><td rowspan=1 colspan=1>Fix. per frame</td><td rowspan=1 colspan=1>AUC</td><td rowspan=1 colspan=1>NSS</td><td rowspan=1 colspan=1>CC</td><td rowspan=1 colspan=1>Sim</td></tr><tr><td rowspan=1 colspan=1>Trained Central Bias</td><td rowspan=1 colspan=1>1</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>0.8725</td><td rowspan=1 colspan=1>1.7646</td><td rowspan=1 colspan=1>0.5297</td><td rowspan=1 colspan=1>0.4812</td></tr><tr><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>RNN(128)</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>0.8745</td><td rowspan=1 colspan=1>1.9505</td><td rowspan=1 colspan=1>0.5495</td><td rowspan=1 colspan=1>0.4962</td></tr><tr><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>LSTM(128)</td><td rowspan=1 colspan=1>80</td><td rowspan=1 colspan=1>0.8866</td><td rowspan=1 colspan=1>2.0155</td><td rowspan=1 colspan=1>0.4606</td><td rowspan=1 colspan=1>0.4219</td></tr><tr><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>LSTM(256)</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>0.8986</td><td rowspan=1 colspan=1>2.5169</td><td rowspan=1 colspan=1>0.6007</td><td rowspan=1 colspan=1>0.5278</td></tr><tr><td rowspan=1 colspan=1>RMDN full</td><td rowspan=1 colspan=1>LSTM(256)</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>0.9037</td><td rowspan=1 colspan=1>2.6455</td><td rowspan=1 colspan=1>0.6129</td><td rowspan=1 colspan=1>0.5349</td></tr></table>",
+        "bbox": [
+            220,
+            540,
+            777,
+            617
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also compared our approach to the state-of-the-art in saliency prediction from video. Table 2 includes the results of the best methods taken from the extensive analysis done in Mathe & Sminchisescu (2015). The table reports also some useful baselines, such as the central bias (CB) and the human accuracy for the task. Note that: 1) CB differs from TCB, since it does not use any training fixations; and 2) the human accuracy is computed in (Mathe & Sminchisescu, 2015) by deriving a saliency map from half of our human subjects and is evaluated with respect to fixations of the remaining ones. Furthermore, Table 2 contrasts the use of static features, motion features and their combination. The last row reports the results obtained with our RMDN model. It is interesting to see that the results obtained with a single type of features (static or motion) have an AUC lower than 0.75, which is even lower than the one obtained by the central bias (0.84). Moreover, the combination reaches the best results when the central bias is combined with engineered features $\\mathbf { \\left( S F { + } M F { + } C B \\right) }$ ). On the other hand, our method outperforms all the methods evaluated in Mathe & Sminchisescu (2015) by a large margin and our results are very close to human performance (the difference is only $3 . 2 \\%$ ). In addition to being the best method in Table 2, our method has several advantages: 1) it does not require any hand-engineering of spatiotemporal features, 2) it performs joint training of the LSTM and the saliency predictor, 3) it is very efficient. Specifically, although we cannot estimate the runtime for prior approaches, we believe that our method is much faster than most of the methods reported in Table 2 as these depend on features that are computationally expensive to extract. Our proposed method takes only 0.08s per clip for inference on GPU: 0.07s to compute C3D features and 0.01s to evaluate the RMDN. ",
+        "bbox": [
+            173,
+            646,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/572b3eb0fa183d49f8d162bb4ade2765d8da3a47ac0ba2d93e4a904336dc57a8.jpg",
+        "table_caption": [
+            "Table 2: Saliency prediction comparison against the state-of-the-art on the Hollywood2 dataset. The top-3 best results for each set are taken from (Mathe & Sminchisescu, 2015) "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Set</td><td rowspan=1 colspan=1>Model</td><td rowspan=1 colspan=1>AUC</td></tr><tr><td rowspan=1 colspan=1>Baselines</td><td rowspan=1 colspan=1>UniformCentral Bias (CB)Trained Central Bias (TCB)Human</td><td rowspan=1 colspan=1>0.5000.8400.8720.936</td></tr><tr><td rowspan=1 colspan=1>SF = Static Features</td><td rowspan=1 colspan=1>Color features (Judd et al., 2009)Saliency map (Oliva &amp; Torralba,2001)Horizon det.(Oliva &amp; Torralba,2001)</td><td rowspan=1 colspan=1>0.6440.7020.741</td></tr><tr><td rowspan=1 colspan=1>MF=Motion Features(Mathe &amp; Sminchisescu,2015)</td><td rowspan=1 colspan=1>FlowmagnitudeFlow bimodalityHOG-MBH det.</td><td rowspan=1 colspan=1>0.6260.6370.743</td></tr><tr><td rowspan=1 colspan=1>Combo(Mathe &amp; Sminchisescu,2015)</td><td rowspan=1 colspan=1>SF (Judd et al., 2009)SF+MFSF+MF+CB</td><td rowspan=1 colspan=1>0.7890.8120.871</td></tr><tr><td rowspan=1 colspan=1>OurMethod</td><td rowspan=1 colspan=1>RMDN</td><td rowspan=1 colspan=1>0.904</td></tr></table>",
+        "bbox": [
+            272,
+            140,
+            725,
+            308
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 ACTION RECOGNITION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            340,
+            375,
+            354
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In order to show how saliency can be used for action recognition we carried out a set of experiments covering two scenarios: 1) using the same dataset where the saliency predictor was trained (Hollywood2) and 2) using a never-seen dataset with a different set of actions (UCF101). ",
+        "bbox": [
+            174,
+            367,
+            823,
+            410
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The results on Hollywood2 are reported in terms of mean Average Precision (mAP) as done by Mathe & Sminchisescu (2015). Table 3 shows an analysis of 1) the impact of using different feature representations as well as 2) the effect of the saliency map. As in Tran et al. (2015), we experimented with different features, namely CONV5 and FC6, which correspond to the fifth convolutional layer and the first fully-connected representation of C3D, respectively. We also tested two ways to use the saliency maps, called in the second column: “feature” and “clip”. In the feature mode (first row, experiments (2-5)), the convolutional representation is multiplied by the saliency map, after resizing it accordingly. In other words, the saliency weights directly the feature representation, similarly to the work of Sharma et al. (2016). In the clip mode (second and third row, experiments (2-5)), we adopted the model presented in Sec. 3.4, where the saliency maps are used to weight the input video pixels. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            569
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The third column of Table 3 (experiment (1)) reports the results using only the original video as input to C3D (referred to as context in Fig. 2). Experiment (2) uses the ground truth saliency maps as soft attention to weight the input of C3D, while in experiment (3) this vector is concatenated with the context features. The last two columns (experiment (4) and (5)) represent the same setup, but in this case we use the saliency maps predicted by our model instead of the ground truth. ",
+        "bbox": [
+            174,
+            575,
+            825,
+            646
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Table 3 shows that the results of CONV5 and FC6 are very close when considering the original video (experiment (1)). The table also shows that the feature mode has lower performance compared to the clip mode (experiment (2)). Moreover, the concatenation (experiment (3)) is effective only when visual attention is used to weight pixels rather than features. Based on the poor performance of the features mode, we decided to experiment only with the clip mode in our study with predicted saliency (experiment (4) and (5)). Also, we decided to use FC6 features for the rest of the paper because the representation is more compact and therefore allows to train the classifiers more quickly. We can notice that even in the case of predicted saliency, the concatenation of FC6 context features and those obtained by weighting the input video with soft-attention (experiment (5)) produces a significant improvement over the original CONV5/FC6 features without attention. Furthermore, a pleasant surprise is represented by the the small difference in results between using the predicted saliency (experiment (5)) versus the ground truth maps (experiment (3)): only $0 . 2 7 \\%$ for FC6 (last row). ",
+        "bbox": [
+            173,
+            652,
+            825,
+            833
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The SVM model complexity for experiment (3) in Table 3 is twice as large as the complexity for (1) and (2) since the feature dimensionality is doubled by construction. The same applies when comparing (5) against (1) and (4). In order to have a more fair comparison, we added PCA dimensionality reduction to experiment (5) in order to match the same feature dimensionality as (1) (and (4)). Although the validation accuracies are very similar, the testing mAP drops from $5 4 . 8 5 \\%$ of experiment (5) to $5 1 . 8 2 \\%$ of the PCA experiment. This is not surprising, since the extra dimensions provided by the use of the saliency map are not redundant with respect to the context representation (1). Therefore, concatenation seems to be an effective way to make use of the saliency map. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/60eca7b33a1421c0da0bd0c25429e5a7325e9802855fe043d6f7c2522fce665d.jpg",
+        "table_caption": [
+            "Table 3: Action categorization results in terms of mAP on the Hollywod2 dataset. Analysis of different ways to use the saliency map and comparison between using the ground truth saliency maps versus those predicted by our model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Saliency</td><td></td><td></td><td colspan=\"2\">Ground Truth</td><td colspan=\"2\">Predicted</td></tr><tr><td>Input</td><td>Saliency Use</td><td>(1) Original</td><td>(2)Weighted</td><td>(3) Concat. (1,2)</td><td>(4)Weighted</td><td>(5)Concat. (1,4)</td></tr><tr><td>CONV5</td><td>Feature</td><td>46.08%</td><td>40.76%</td><td>45.62%</td><td>N/A</td><td>N/A</td></tr><tr><td>CONV5</td><td>Clip</td><td>46.08%</td><td>44.89%</td><td>55.49%</td><td>39.42%</td><td>53.41%</td></tr><tr><td>FC6</td><td>Clip</td><td>47.00%</td><td>41.78%</td><td>55.12%</td><td>39.00%</td><td>54.85%</td></tr></table>",
+        "bbox": [
+            176,
+            165,
+            821,
+            231
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/0b44c8a9621cb88a2e8466c9ad86ff9f8f508791207b584de2de1c6e21781085.jpg",
+        "table_caption": [
+            "Table 4: Recognition results in terms of mAP for the Hollywood2 dataset. The proposed method (RMDN) is compared to the approaches reported by Mathe & Sminchisescu (2015) (named as central bias and saliency sampling). Note that Mathe & Sminchisescu (2015) and RDMN do not use the same video classification model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1></td><td rowspan=1 colspan=5>Ground Truth</td><td rowspan=1 colspan=3>Predicted</td></tr><tr><td rowspan=1 colspan=1>Class</td><td rowspan=1 colspan=4>SalSampling</td><td rowspan=1 colspan=1>our RMDN</td><td rowspan=1 colspan=1>Central Bias</td><td rowspan=1 colspan=1>SalSampling</td><td rowspan=1 colspan=1>our RMDN</td></tr><tr><td rowspan=4 colspan=1>AnswerPhoneDriveCarEatFightPerson</td><td rowspan=1 colspan=4>28.1%</td><td rowspan=1 colspan=1>21.8%</td><td rowspan=1 colspan=1>23.3%</td><td rowspan=1 colspan=1>23.7%</td><td rowspan=1 colspan=1>29.8%</td></tr><tr><td rowspan=1 colspan=4>94.8%</td><td rowspan=1 colspan=1>89.2%</td><td rowspan=1 colspan=1>92.4%</td><td rowspan=1 colspan=1>92.8%</td><td rowspan=1 colspan=1>91.6%</td></tr><tr><td rowspan=1 colspan=4>67.3%</td><td rowspan=1 colspan=1>59.4%</td><td rowspan=1 colspan=1>58.6%</td><td rowspan=1 colspan=1>70.0%</td><td rowspan=1 colspan=1>49.1%</td></tr><tr><td rowspan=1 colspan=4>80.6%</td><td rowspan=1 colspan=1>80.9%</td><td rowspan=1 colspan=1>76.3%</td><td rowspan=1 colspan=1>76.1%</td><td rowspan=1 colspan=1>79.2%</td></tr><tr><td rowspan=5 colspan=1>GetOutCarHandShakeHugPersonKissRun</td><td rowspan=2 colspan=4>55.1%27.6%</td><td rowspan=1 colspan=1>78.0%</td><td rowspan=1 colspan=1>49.6%</td><td rowspan=1 colspan=1>54.9%</td><td rowspan=1 colspan=1>76.9%</td></tr><tr><td rowspan=1 colspan=3>27.6%</td><td rowspan=1 colspan=1>58.6%</td><td rowspan=1 colspan=1>26.5%</td><td rowspan=1 colspan=1>27.9%</td><td rowspan=1 colspan=1>47.0%</td></tr><tr><td rowspan=1 colspan=2></td><td></td><td rowspan=1 colspan=1>37.8%</td><td rowspan=1 colspan=1>27.5%</td><td rowspan=1 colspan=1>34.6%</td><td rowspan=1 colspan=1>39.5%</td><td rowspan=1 colspan=1>37.9%</td></tr><tr><td rowspan=2 colspan=4>66.4%85.7%</td><td rowspan=1 colspan=1>66.4%</td><td rowspan=1 colspan=1>52.2%</td><td rowspan=1 colspan=1>62.1%</td><td rowspan=1 colspan=1>61.3%</td><td rowspan=2 colspan=1>51.0%83.2%</td></tr><tr><td rowspan=1 colspan=1>85.5%</td><td rowspan=1 colspan=1>77.8%</td><td rowspan=1 colspan=1>82.2%</td></tr><tr><td rowspan=1 colspan=1>SitDown</td><td rowspan=1 colspan=4>62.5%</td><td rowspan=1 colspan=1>31.8%</td><td rowspan=1 colspan=1>62.1%</td><td rowspan=1 colspan=1>69.0%</td><td rowspan=3 colspan=1>31.4%39.7%41.3%</td></tr><tr><td rowspan=1 colspan=1>SitUp</td><td rowspan=1 colspan=4>30.7%</td><td rowspan=1 colspan=1>38.0%</td><td rowspan=1 colspan=1>20.9%</td><td rowspan=1 colspan=1>29.7%</td></tr><tr><td rowspan=1 colspan=1>StandUp</td><td rowspan=1 colspan=4>58.2%</td><td rowspan=1 colspan=1>37.8%</td><td rowspan=1 colspan=1>61.3%</td><td rowspan=1 colspan=1>63.9%</td></tr><tr><td rowspan=1 colspan=1>Mean</td><td rowspan=1 colspan=4>57.9%</td><td rowspan=1 colspan=1>55.1%</td><td rowspan=1 colspan=1>53.7%</td><td rowspan=1 colspan=1>57.6%</td><td rowspan=1 colspan=1>54.8%</td></tr></table>",
+        "bbox": [
+            232,
+            323,
+            764,
+            507
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            547,
+            823,
+            577
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Table 4 compares our action categorization results with those presented in Mathe & Sminchisescu (2015). As we did before, we separate experiments that use the ground truth maps and those that use predicted saliency. The results of Table 4 show that the performance our method (second and fifth column) is around $2 \\%$ lower than Mathe & Sminchisescu (2015). However this is most likely explained by the differences in the type of features and classifier, and not by the differences in saliency map prediction methods. Indeed, we already established in Table 2 that our proposed saliency map predictor is more accurate than the one proposed in Mathe & Sminchisescu (2015). On the other hand, Mathe & Sminchisescu (2015) use a combination of many different features and a kernel chi-square SVM, while our method uses C3D features with a simple linear SVM classifier. Adding more non-linearities, especially for the concatenation experiment, would probably help. But we consider the experimentation with different types of action recognition features and classifiers out of the scope of this paper. ",
+        "bbox": [
+            174,
+            583,
+            825,
+            750
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Finally, we perform an experiment to assess the generalization abilities of the learned saliency model to a different dataset, with classes and videos that have not been seen during its training. To this end, we used the attentional model trained on the Hollywood2 dataset to extract saliency maps on the UCF101 dataset. As saliency ground truth is not available for UCF101, we evaluate performance in terms of action recognition accuracy using the evaluation protocol and splits by Soomro et al. (2012). Table 5 summarizes the results. The proposed method $( \\mathrm { C 3 D + R M D N }$ , eight row) corresponds to the concatenation of the original C3D descriptor and the C3D descriptor with the input weighted by the saliency map, as was done in the Hollywood2 experiments. We compare our method with the results obtained using the C3D descriptor computed from the context only (seventh row) and other state-ofthe-art methods (first row through sixth row). A linear SVM trained on C3D features computed from the context already outperforms most of the other methods (first row to forth row). But training the linear SVM on a concatenation of context C3D features and those obtained by reweighting the video input with the RMDN saliency maps (seventh row) leads to a further improvement of $1 . 1 \\%$ . This is an impressive result since the RMDN was trained on the separate and small Hollywood2 dataset. ",
+        "bbox": [
+            174,
+            757,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Since we noticed that the saliency maps of RMDN for UCF101 tend to be highly peaked around a single location in each frame, we added the trained central bias (already analyzed in Table 1). This has the effect of diffusing the saliency map with the central bias, thus enlarging the area of attention used by the recognition system. The result of this experiment, which is reported in the last row of Table 5, further improves the accuracy by $1 . 3 \\%$ . ",
+        "bbox": [
+            174,
+            138,
+            825,
+            208
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "table",
+        "img_path": "images/d044b8ec89e54ac6e65e2156a6eeddb426e12b640e2aecdd4d07b1121b9855cb.jpg",
+        "table_caption": [
+            "Table 5: Action categorization results in terms of 3-fold accuracy on the UCF101 dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>Accuracy</td></tr><tr><td>Imagenet+linear SVM iDT(Wang&amp; Schmid,2013)+BoW+ linear SVM Spatial stream network (Simonyan &amp; Zisserman,2014) LSTM composite model (Srivastava et al., 2015) scLSTM(Song et al., 2016) LSTM(optical flow, images) (Yue-Hei Ng et al., 2015)</td><td>68.8% 76.2% 72.6% 75.8% 84.0% 88.6%</td></tr><tr><td>C3D+linear SVM C3D+RMDN+ linear SVM C3D+RMDN+TCB+ linear SVM</td><td>80.4% 81.5% 82.8%</td></tr></table>",
+        "bbox": [
+            300,
+            248,
+            696,
+            372
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            406,
+            328,
+            422
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed a recurrent mixture density network for spatiotemporal visual attention. We showed that our model outperforms state-of-the-art methods for saliency prediction in videos. We have also shown that the saliency maps generated by our model can be leveraged to improve action categorization using a very simple procedure. This suggests that saliency can enrich the original video representation. The runtime overhead to estimate the saliency map is very small: only 0.01s added to the feature extraction time of 0.07s. ",
+        "bbox": [
+            174,
+            438,
+            825,
+            521
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "As future work, we plan to close the gap between RMDN and action recognition with a joint network. The idea is to have as output of the model both the saliency map at each time and the class of the action for the entire video. This can be combined with the idea of using the saliency map estimated at the previous time to weight the input for the current time. Putting together these two ideas in a single network would result in a joint model for saliency prediction and action recognition. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            619,
+            387,
+            635
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We thank Du Tran for helpful discussion about the code of the C3D network and its usage. We are grateful to Stefan Mathe for explaining the format of the eyetracking data and the protocol of the Hollywood2 experiment. This work was funded in part by NSF award CNS-1205521. We gratefully acknowledge NVIDIA for the donation of GPUs used for portions of this work. ",
+        "bbox": [
+            174,
+            651,
+            825,
+            707
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            728,
+            285,
+            743
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jimmy Ba, Volodymyr Mnih, and Koray Kavukcuoglu. Multiple object recognition with visual attention. In Proceedings of the International Conference on Learning Representations (ICLR), 2015. ",
+        "bbox": [
+            174,
+            752,
+            823,
+            794
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "L. Bazzani, N. de Freitas, H. Larochelle, V. Murino, and J-A Ting. Learning attentional policies for object tracking and recognition in video with deep networks. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 937–944, June 2011. ",
+        "bbox": [
+            176,
+            804,
+            821,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher M Bishop. Mixture density networks. In Technical Report. Aston University, 1994. ",
+        "bbox": [
+            173,
+            856,
+            800,
+            872
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A. Borji and L. Itti. State-of-the-art in visual attention modeling. IEEE Transactions on Pattern Analysis and Machine Intelligence, 35(1):185–207, Jan 2013. ISSN 0162-8828. doi: 10.1109/ TPAMI.2012.89. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ali Borji, Dicky N Sihite, and Laurent Itti. Quantitative analysis of human-model agreement in visual saliency modeling: A comparative study. Image Processing, IEEE Transactions on, 22(1): 55–69, 2013. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Neil DB Bruce, Christopher Catton, and Sasa Janjic. A deeper look at saliency: Feature contrast, semantics, and beyond. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 516–524, 2016. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. Chaabouni, J. Benois-Pineau, and C. Ben Amar. Transfer learning with deep networks for saliency prediction in natural video. In 2016 IEEE International Conference on Image Processing (ICIP), pp. 1604–1608, Sept 2016a. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            251
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Souad Chaabouni, Jenny Benois-Pineau, Ofer Hadar, and Chokri Ben Amar. Deep learning for saliency prediction in natural video. CoRR, abs/1604.08010, 2016b. ",
+        "bbox": [
+            173,
+            260,
+            823,
+            290
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jennifer T. Coull. fmri studies of temporal attention: allocating attention within, or towards, time. Cognitive Brain Research, 21(2):216 – 226, 2004. Neuroimaging of Interval Timing. ",
+        "bbox": [
+            173,
+            299,
+            823,
+            328
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "M. Denil, L. Bazzani, H. Larochelle, and N. de Freitas. Learning where to attend with deep architectures for image tracking. Neural Computation, 2012. ",
+        "bbox": [
+            173,
+            337,
+            823,
+            367
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Y. Gitman, M. Erofeev, D. Vatolin, B. Andrey, and F. Alexey. Semiautomatic visual-attention modeling and its application to video compression. In Image Processing (ICIP), 2014 IEEE International Conference on, pp. 1105–1109, Oct 2014. doi: 10.1109/ICIP.2014.7025220. ",
+        "bbox": [
+            176,
+            376,
+            820,
+            419
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Graves. Generating sequences with recurrent neural networks. CoRR, abs/1308.0850, 2013. ",
+        "bbox": [
+            169,
+            428,
+            810,
+            444
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karol Gregor, Ivo Danihelka, Alex Graves, Danilo Rezende, and Daan Wierstra. Draw: A recurrent neural network for image generation. In David Blei and Francis Bach (eds.), Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 1462–1471. JMLR Workshop and Conference Proceedings, 2015. ",
+        "bbox": [
+            173,
+            452,
+            823,
+            508
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Chenlei Guo, Qi Ma, and Liming Zhang. Spatio-temporal saliency detection using phase spectrum of quaternion fourier transform. In Computer vision and pattern recognition, 2008. cvpr 2008. ieee conference on, pp. 1–8. IEEE, 2008. ",
+        "bbox": [
+            174,
+            517,
+            823,
+            561
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jonathan Harel, Christof Koch, and Pietro Perona. Graph-based visual saliency. In Advances in neural information processing systems, pp. 545–552, 2006. ",
+        "bbox": [
+            171,
+            570,
+            823,
+            601
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8): 1735–1780, 1997. ",
+        "bbox": [
+            173,
+            609,
+            823,
+            637
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Sayed Hossein Khatoonabadi, Nuno Vasconcelos, Ivan V. Bajic, and Yufeng Shan. How many bits does it take for a stimulus to be salient? In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            174,
+            647,
+            825,
+            689
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Xun Huang, Chengyao Shen, Xavier Boix, and Qi Zhao. Salicon: Reducing the semantic gap in saliency prediction by adapting deep neural networks. In The IEEE International Conference on Computer Vision (ICCV), December 2015. ",
+        "bbox": [
+            173,
+            699,
+            826,
+            742
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Saumya Jetley, Naila Murray, and Eleonora Vig. End-to-end saliency mapping via probability distribution prediction. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2016. ",
+        "bbox": [
+            174,
+            751,
+            821,
+            795
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ming Jiang, Juan Xu, and Qi Zhao. Saliency in crowd. In Computer Vision–ECCV 2014, pp. 17–32. Springer, 2014. ",
+        "bbox": [
+            171,
+            804,
+            821,
+            833
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tilke Judd, Krista Ehinger, Fredo Durand, and Antonio Torralba. Learning to predict where humans ´ look. In Computer Vision, 2009 IEEE 12th international conference on, pp. 2106–2113. IEEE, 2009. ",
+        "bbox": [
+            174,
+            843,
+            823,
+            885
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tilke Judd, Fredo Durand, and Antonio Torralba. A benchmark of computational models of saliency´ to predict human fixations. In MIT Technical Report, 2012. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "S. Karthikeyan, Thuyen Ngo, Miguel Eckstein, and B.S. Manjunath. Eye tracking assisted extraction of attentionally important objects from videos. In IEEE International Conference on Computer Vision and Pattern Recognition, Jun 2015. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Matthias Kummerer, Lucas Theis, and Matthias Bethge. Deep gaze I: boosting saliency prediction ¨ with feature maps trained on imagenet. In ICLR, 2015. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Hugo Larochelle and Geoffrey E. Hinton. Learning to combine foveal glimpses with a third-order Boltzmann machine. In Advances in Neural Information Processing Systems 23 (NIPS 2010), pp. 1243–1251, Vancouver, Canada, 2010. ",
+        "bbox": [
+            176,
+            193,
+            821,
+            236
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Guanbin Li and Yizhou Yu. Visual saliency based on multiscale deep features. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            173,
+            244,
+            823,
+            273
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Nian Liu, Junwei Han, Dingwen Zhang, Shifeng Wen, and Tianming Liu. Predicting eye fixations using convolutional neural networks. In IEEE Conference on Computer Vision and Pattern Recognition, CVPR 2015, Boston, MA, USA, June 7-12, 2015, pp. 362–370, 2015. ",
+        "bbox": [
+            173,
+            281,
+            825,
+            325
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aravindh Mahendran and Andrea Vedaldi. Salient deconvolutional networks. In European Conference on Computer Vision, pp. 120–135. Springer, 2016. ",
+        "bbox": [
+            173,
+            333,
+            821,
+            363
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Marcin Marszałek, Ivan Laptev, and Cordelia Schmid. Actions in context. In IEEE Conference on Computer Vision & Pattern Recognition, 2009. ",
+        "bbox": [
+            173,
+            371,
+            821,
+            401
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "S. Mathe and C. Sminchisescu. Actions in the eye: Dynamic gaze datasets and learnt saliency models for visual recognition. IEEE Transactions on Pattern Analysis and Machine Intelligence, 37(7):1408–1424, July 2015. ISSN 0162-8828. doi: 10.1109/TPAMI.2014.2366154. ",
+        "bbox": [
+            173,
+            409,
+            823,
+            453
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thomas Mauthner, Horst Possegger, Georg Waltner, and Horst Bischof. Encoding based saliency detection for videos and images. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            505
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Volodymyr Mnih, Nicolas Heess, Alex Graves, et al. Recurrent models of visual attention. In Advances in Neural Information Processing Systems, pp. 2204–2212, 2014. ",
+        "bbox": [
+            173,
+            512,
+            825,
+            542
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aude Oliva and Antonio Torralba. Modeling the shape of the scene: A holistic representation of the spatial envelope. Int. J. Comput. Vision, 42(3):145–175, May 2001. ",
+        "bbox": [
+            171,
+            551,
+            823,
+            580
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Junting Pan and Xavier Giro i Nieto. End-to-end convolutional network for saliency prediction. ´ CoRR, abs/1507.01422, 2015. ",
+        "bbox": [
+            171,
+            588,
+            823,
+            617
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Dmitry Rudoy, Dan B. Goldman, Eli Shechtman, and Lihi Zelnik-Manor. Learning video saliency from human gaze using candidate selection. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2013. ",
+        "bbox": [
+            174,
+            626,
+            823,
+            670
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Michael Sapienza, Fabio Cuzzolin, and Philip HS Torr. Learning discriminative space–time action parts from weakly labelled videos. International Journal of Computer Vision, 110(1):30–47, 2014. ",
+        "bbox": [
+            174,
+            678,
+            823,
+            720
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet, Andrea Frome, and Esteban Real. Attention for fine-grained categorization. CoRR, abs/1412.7054, 2014. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Shikhar Sharma, Ryan Kiros, and Ruslan Salakhutdinov. Action recognition using visual attention. In ICLR workshops, 2016. ",
+        "bbox": [
+            171,
+            767,
+            821,
+            796
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "K. Simonyan, A. Vedaldi, and A. Zisserman. Deep inside convolutional networks: Visualising image classification models and saliency maps. In Proceedings of the International Conference on Learning Representations (ICLR), 2014. ",
+        "bbox": [
+            176,
+            805,
+            823,
+            848
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Two-stream convolutional networks for action recognition in videos. In Advances in Neural Information Processing Systems, pp. 568–576, 2014. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            887
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jingkuan Song, Heng Shen, et al. Beyond frame-level cnn: Saliency-aware 3d cnn with lstm for video action recognition. IEEE Signal Processing Letters, 2016. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Khurram Soomro, Amir Roshan Zamir, and Mubarak Shah. Ucf101: A dataset of 101 human actions classes from videos in the wild. arXiv preprint arXiv:1212.0402, 2012. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Srivastava, Elman Mansimov, and Ruslan Salakhudinov. Unsupervised learning of video representations using lstms. In David Blei and Francis Bach (eds.), Proceedings of the 32nd International Conference on Machine Learning (ICML-15), pp. 843–852. JMLR Workshop and Conference Proceedings, 2015. ",
+        "bbox": [
+            174,
+            141,
+            825,
+            196
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Cristian Sminchisescu Stefan Mathe. Action from still image dataset and inverse optimal control to learn task specific visual scanpaths. In Advances in Neural Information Processing Systems, 2013. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            248
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Du Tran, Lubomir Bourdev, Rob Fergus, Lorenzo Torresani, and Manohar Paluri. Learning spatiotemporal features with 3d convolutional networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 4489–4497, 2015. ",
+        "bbox": [
+            174,
+            257,
+            826,
+            301
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eleonora Vig, Michael Dorr, and David Cox. Space-variant descriptor sampling for action recognition based on saliency and eye movements. In European conference on computer vision, pp. 84–97. Springer, 2012. ",
+        "bbox": [
+            173,
+            309,
+            825,
+            353
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Heng Wang and Cordelia Schmid. Action recognition with improved trajectories. In Proceedings of the IEEE International Conference on Computer Vision, pp. 3551–3558, 2013. ",
+        "bbox": [
+            171,
+            361,
+            823,
+            391
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kelvin Xu, Jimmy Ba, Ryan Kiros, Kyunghyun Cho, Aaron Courville, Ruslan Salakhudinov, Rich Zemel, and Yoshua Bengio. Show, attend and tell: Neural image caption generation with visual attention. In Proceedings of the 32nd International Conference on Machine Learning, ICML 2015, Lille, France, 6-11 July 2015, pp. 2048–2057, 2015. ",
+        "bbox": [
+            173,
+            398,
+            825,
+            457
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Li Yao, Atousa Torabi, Kyunghyun Cho, Nicolas Ballas, Christopher Pal, Hugo Larochelle, and Aaron Courville. Describing Videos by Exploiting Temporal Structure. In IEEE International Conference on Computer Vision (ICCV), pp. 4507–4515, 2015. ",
+        "bbox": [
+            174,
+            463,
+            825,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Donggeun Yoo, Sunggyun Park, Joon-Young Lee, Anthony S. Paek, and In So Kweon. Attentionnet: Aggregating weak directions for accurate object detection. In The IEEE International Conference on Computer Vision (ICCV), December 2015. ",
+        "bbox": [
+            173,
+            516,
+            823,
+            559
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Y. Yu, G. K. I. Mann, and R. G. Gosine. An object-based visual attention model for robotic applications. IEEE Transactions on Systems, Man, and Cybernetics, Part B (Cybernetics), 40(5): 1398–1412, Oct 2010. ISSN 1083-4419. doi: 10.1109/TSMCB.2009.2038895. ",
+        "bbox": [
+            176,
+            568,
+            823,
+            611
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Joe Yue-Hei $\\mathrm { N g }$ , Matthew Hausknecht, Sudheendra Vijayanarasimhan, Oriol Vinyals, Rajat Monga, and George Toderici. Beyond short snippets: Deep networks for video classification. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 4694–4702, 2015. ",
+        "bbox": [
+            173,
+            618,
+            825,
+            675
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yun Zhai and Mubarak Shah. Visual attention detection in video sequences using spatiotemporal cues. In Proceedings of the 14th annual ACM international conference on Multimedia, pp. 815– 824. ACM, 2006. ",
+        "bbox": [
+            174,
+            684,
+            825,
+            727
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiaping Zhao, Christian Siagian, and Laurent Itti. Fixation bank: Learning to reweight fixation candidates. In The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2015. ",
+        "bbox": [
+            173,
+            736,
+            825,
+            779
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yin Zheng, Yu-Jin Zhang, and Hugo Larochelle. A Neural Autoregressive Approach to Attentionbased Recognition. International Journal of Computer Vision, 113(1):67–79, 2015. ",
+        "bbox": [
+            173,
+            787,
+            823,
+            816
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d470b16271fd4e81b71930ff5c6a7c114bb58481fc13642ea4fa49701e22f715.jpg",
+        "image_caption": [
+            "Figure 2: Model for action recognition. The original clip of $K$ frames is fed into a 3D convolutional network. The same clip is then weighted by the predicted saliency map estimated by our RMDN and then fed into the 3D convolutional network. The final clip-level representation is then concatenated. All the clips of a video are merged using pooling and then a linear classifier can be trained. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            113,
+            740,
+            376
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A SALIENCY FOR CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            483,
+            480,
+            498
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The proposed model for recognition is presented in Fig. 2. At each time $t$ , we extract two representations: the context branch is given by the C3D representation of the original clip, while the soft attentional branch is given by the C3D representation of the input clip weighted by the saliency map. The two representations are then concatenated at the clip level and max-pooled over the video to obtain the final video-level descriptor. This video-level representation is then used as input to train the video classifier which is a linear SVM in our experiments. ",
+        "bbox": [
+            174,
+            516,
+            825,
+            599
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, we also evaluated the option of weighting the convolutional feature map $\\mathbf { x } _ { t }$ instead of the input, as for example done by Sharma et al. (2016). However, we will see that soft-masking the input gives higher accuracy, probably because applying C3D’s non-linear transformation after the soft-weighting produces a representation that is less redundant with the original (non-masked) C3D representation. ",
+        "bbox": [
+            174,
+            607,
+            823,
+            678
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B IMPLEMENTATION DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            702,
+            437,
+            717
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We used the pretrained C3D network (Tran et al., 2015) as feature representation which is the input of the LSTM network. The convolutional layer before the fully-connected layers is used for saliency prediction, while the last fully-connected layer before the softmax is used for classification, since Tran et al. (2015) showed to obtain the best performance. ",
+        "bbox": [
+            174,
+            734,
+            823,
+            791
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The training of the RMDN is performed using RMSprop with adaptive learning rate and gradient clipping. We start from a learning rate of 0.0003 and after 8 epochs it is reduced at each epoch with a decay factor of 0.95. The gradient is clipped with a threshold of 20. Dropout with a ratio of 0.5 is applied only on the hidden layer of the LSTM network before the MDN. We trained for 40 epochs, but training is stopped if there is no significative improvement of the loss. During training, temporal data augmentation is performed by clipping the videos to shorter videos of length 65 frames (which corresponds to $5 0 \\mathrm { C } 3 \\mathrm { D }$ descriptors since it needs a buffer of 16 frames for the first descriptor). The number of components of the GMM $C$ is fixed to 20 for all the experiments. All the experiments were carried out using an NVIDIA Tesla K40 card. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "After extracting the saliency maps and the feature representations on GPU, our recognition experiments were performed on CPU using a linear SVM. In order to compute the video-level representation, we performed max pooling of the clip-level representations of the video. For all the experiments, we used $2 0 \\%$ of the training data as validation set to find the regularization parameter of the SVM. We searched the parameter space on a grid between $1 0 ^ { - 9 }$ to $1 0 ^ { 3 }$ with a step of $1 0 ^ { \\frac { 1 } { 2 } }$ . Finally, we retrain the SVM on all the training set (including the validation set) using the best cross-validated parameter. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            203
+        ],
+        "page_idx": 14
+    }
+]

parse/train/SkgEaj05t7/SkgEaj05t7.md

@@ -0,0 +1,316 @@
+# On the relation between the sharpest directions of DNN loss and the SGD step length
+
+Stanisław Jastrzębsk $^ { 1 , 2 }$ , Zachary Kenton $^ 2$ , Nicolas Ballas $^ 3$ , Asja Fischer $^ 4$ , Yoshua Bengio $^ { 2 , 5 }$ , and Amos Storkey6
+
+1Jagiellonian University $^ 2$ Mila / University of Montreal 3Facebook AI Research $^ 4$ Ruhr University Bochum $^ 5$ CIFAR Senior Fellow $^ 6$ School of Informatics, University of Edinburgh
+
+# Abstract
+
+Stochastic Gradient Descent (SGD) based training of neural networks with a large learning rate or a small batch-size typically ends in well-generalizing, flat regions of the weight space, as indicated by small eigenvalues of the Hessian of the training loss. However, the curvature along the SGD trajectory is poorly understood. An empirical investigation shows that initially SGD visits increasingly sharp regions, reaching a maximum sharpness determined by both the learning rate and the batch-size of SGD. When studying the SGD dynamics in relation to the sharpest directions in this initial phase, we find that the SGD step is large compared to the curvature and commonly fails to minimize the loss along the sharpest directions. Furthermore, using a reduced learning rate along these directions can improve training speed while leading to both sharper and better generalizing solutions compared to vanilla SGD. In summary, our analysis of the dynamics of SGD in the subspace of the sharpest directions shows that they influence the regions that SGD steers to (where larger learning rate or smaller batch size result in wider regions visited), the overall training speed, and the generalization ability of the final model.
+
+# 1 Introduction
+
+Deep Neural Networks (DNNs) are often massively over-parameterized (Zhang et al., 2016), yet show state-of-the-art generalization performance on a wide variety of tasks when trained with Stochastic Gradient Descent (SGD). While understanding the generalization capability of DNNs remains an open challenge, it has been hypothesized that SGD acts as an implicit regularizer, limiting the complexity of the found solution (Poggio et al., 2017; Advani and Saxe, 2017; Wilson et al., 2017; Jastrzębski et al., 2017).
+
+Various links between the curvature of the final minima reached by SGD and generalization have been studied (Murata et al., 1994; Neyshabur et al., 2017). In particular, it is a popular view that models corresponding to wide minima of the loss in the parameter space generalize better than those corresponding to sharp minima (Hochreiter and Schmidhuber, 1997; Keskar et al., 2016; Jastrzębski et al., 2017; Wang et al., 2018). The existence of this empirical correlation between the curvature of the final minima and generalization motivates our study.
+
+Our work aims at understanding the interaction between SGD and the sharpest directions of the loss surface, i.e. those corresponding to the largest eigenvalues of the Hessian. In contrast to studies such as those by Keskar et al. (2016) and Jastrzębski et al. (2017) our analysis focuses on the whole training trajectory of SGD rather than just on the endpoint. We will show in Sec. 3.1 that the evolution of the largest eigenvalues of the Hessian follows a consistent pattern for the different networks and datasets that we explore. Initially, SGD is in a region of broad curvature, and as the loss decreases, SGD visits regions in which the top eigenvalues of the Hessian are increasingly large, reaching a peak value with a magnitude influenced by both learning rate and batch size. After that point in training, we typically observe a decrease or stabilization of the largest eigenvalues.
+
+![](images/af3b010f678c94c04a8ccab7fe1028e5d324e84be04e1b879a329efe0c14e1fa.jpg)  
+Figure 1: Left: Outline of the phenomena discussed in the paper. Curvature along the sharpest direction(s) initially grows (A to C). In most iterations, we find that SGD crosses the minimum if restricted to the subspace of the sharpest direction(s) by taking a too large step (B and C). Finally, curvature stabilizes or decays with a peak value determined by learning rate and batch size (C, see also right). Right two: Representative example of the evolution of the top 30 (decreasing, red to blue) eigenvalues of the Hessian for a SimpleCNN model during training (with $\eta = 0 . 0 0 5$ , note that $\eta$ is close to $\begin{array} { r } { \frac { 1 } { \lambda _ { m a x } } = \frac { 1 } { 1 6 0 } } \end{array}$ 1160 ).
+
+To further understand this phenomenon, we study the dynamics of SGD in relation to the sharpest directions in Sec. 3.2 and Sec. 3.3. Projecting to the sharpest directions1, we see that the regions visited in the beginning resemble bowls with curvatures such that an SGD step is typically too large, in the sense that an SGD step cannot get near the minimum of this bowl-like subspace; rather it steps from one side of the bowl to the other, see Fig. 1 for an illustration.
+
+Finally in Sec. 4 we study further practical consequences of our observations and investigate an SGD variant which uses a reduced and fixed learning rate along the sharpest directions. In most cases we find this variant optimizes faster and leads to a sharper region, which generalizes the same or better compared to vanilla SGD with the same (small) learning rate. While we are not proposing a practical optimizer, these results may open a new avenue for constructing effective optimizers tailored to the DNNs’ loss surface in the future.
+
+On the whole this paper exposes and analyses SGD dynamics in the subspace of the sharpest directions. In particular, we argue that the SGD dynamics along the sharpest directions influence the regions that SGD steers to (where larger learning rate or smaller batch size result in wider regions visited), the training speed, and the final generalization capability.
+
+# 2 Experimental setup and notation
+
+We perform experiments mainly on Resnet- $3 2 ^ { 2 }$ and a simple convolutional neural network, which we refer to as SimpleCNN (details in the Appendix D), and the CIFAR-10 dataset (Krizhevsky et al.). SimpleCNN is a 4 layer CNN, achieving roughly $8 6 \%$ test accuracy on the CIFAR-10 dataset. For training both of the models we use standard data augmentation on CIFAR-10 and for Resnet-32 L2 regularization with coefficient 0.005. We additionally investigate the training of VGG-11 (Simonyan and Zisserman, 2014) on the CIFAR-10 dataset (we adapted the final classification layers for 10 classes) and of a bidirectional Long Short Term Memory (LSTM) model (following the “small” architecture employed by Zaremba et al. (2014), with added dropout regularization of 0.1) on the Penn Tree Bank (PTB) dataset. All models are trained using SGD, without using momentum, if not stated otherwise.
+
+![](images/d6bf8efa1856dce311c9fa72c0cc48588f6f4e5bb4fa7802e129a0890f4487dd.jpg)  
+Figure 2: Top: Evolution of the top 10 eigenvalues of the Hessian for SimpleCNN and Resnet-32 trained on the CIFAR-10 dataset with $\eta = 0 . 1$ and $S = 1 2 8$ . Bottom: Zoom on the evolution of the top 10 eigenvalues in the beginning of training. A sharp initial growth of the largest eigenvalues followed by an oscillatory-like evolution is visible. Training and test accuracy of the corresponding models are provided for reference.
+
+The notation and terminology we use in this paper are now described. We will use $t$ (time) to refer to epoch or iteration, depending on the context. By and $S$ we denote $\eta$ the SGD learning rate and batch size, respectively. $\mathbf { H }$ is the Hessian of the empirical loss at the current $D$ -dimensional parameter value evaluated on the training set, and its eigenvalues are denoted as $\lambda _ { i }$ , $i = 1 \ldots D$ (ordered by decreasing absolute magnitudes). $\lambda _ { m a x } { = \lambda _ { 1 } }$ is the maximum eigenvalue, which is equivalent to the spectral norm of $\mathbf { H }$ . The top $K$ eigenvectors of $\mathbf { H }$ are denoted by $e _ { i }$ , for $i \in \{ 1 , \ldots , K \}$ , and referred to in short as the sharpest directions. We will refer to the mini-batch gradient calculated based on a batch of size $S$ as $\mathbf { \pmb { g } } ^ { ( S ) } ( t )$ and to ${ \eta } { \pmb g } ^ { ( S ) } ( t )$ as the $S G D$ step. We will often consider the projection of this gradient onto one of the top eigenvectors, given by $\tilde { \mathbf { g } } _ { i } ( t ) = \tilde { g } _ { i } ( t ) e _ { i } ( t )$ , where $\tilde { g } _ { i } ( t ) \equiv \langle \pmb { g } ^ { ( S ) } ( t ) , \pmb { e } _ { i } ( t ) \rangle$ . Computing the full spectrum of the Hessian $\mathbf { H }$ for reasonably large models is computationally infeasible. Therefore, we approximate the top $K$ (up to 50) eigenvalues using the Lanczos algorithm (Lanczos, 1950; Dauphin et al., 2014), an extension of the power method, on approximately $5 \%$ of the training data (using more data was not beneficial). When regularization was applied during training (such as dropout, L2 or data augmentation), we apply the same regularization when estimating the Hessian. This ensures that the Hessian reflects the loss surface accessible to SGD. The code for the project is made available at https://github.com/kudkudak/dnn_sharpest_directions.
+
+# 3 A study of the Hessian along the SGD path
+
+In this section, we study the eigenvalues of the Hessian of the training loss along the SGD optimization trajectory, and the SGD dynamics in the subspace corresponding to the largest eigenvalues. We highlight that SGD steers from the beginning towards increasingly sharp regions until some maximum is reached; at this peak the SGD step length is large compared to the curvature along the sharpest directions (see Fig. 1 for an illustration). Moreover, SGD visits flatter regions for a larger learning rate or a smaller batch-size.
+
+# 3.1 Largest eigenvalues of the Hessian along the SGD path
+
+We first investigate the training loss curvature in the sharpest directions, along the training trajectory for both the SimpleCNN and Resnet-32 models.
+
+Largest eigenvalues of the Hessian grow initially. In the first experiment we train SimpleCNN and Resnet-32 using SGD with $\eta = 0 . 1$ and $S = 1 2 8$ and estimate the 10 largest eigenvalues of the Hessian, throughout training. As shown in Fig. 2 (top) the spectral norm (which corresponds to the largest eigenvalue), as well as the other tracked eigenvalues, grows in the first epochs up to a maximum value. After reaching this maximum value, we observe a relatively steady decrease of the largest eigenvalues in the following epochs.
+
+To investigate the evolution of the curvature in the first epochs more closely, we track the eigenvalues at each iteration during the beginning of training, see Fig. 2 (bottom). We observe that initially the magnitudes of the largest eigenvalues grow rapidly. After this initial growth, the eigenvalues alternate between decreasing and increasing; this behaviour is also reflected in the evolution of the accuracy. This suggests SGD is initially driven to regions that are difficult to optimize due to large curvature.
+
+To study this further we look at a full-batch gradient descent training of Resnet- $3 2 ^ { 3 }$ . This experiment is also motivated by the instability of large-batch size training reported in the literature, as for example by Goyal et al. (2017). In the case of Resnet-32 (without Batch-Normalization) we can clearly see that the magnitude of the largest eigenvalues of the Hessian grows initially, which is followed by a sharp drop in accuracy suggesting instability of the optimization, see Fig. 3. We also observed that the instability is partially solved through use of Batch-Normalization layers, consistent with the findings of Bjorck et al. (2018), see Fig. 9 in Appendix. Finally, we report some additional results on the late phase of training, e.g. the impact of learning rate schedules, in Fig. 12 in the Appendix.
+
+![](images/242d3d5d962f495e4ce27838e2a86e82a44ada76f35b05119ca7830db38c638f.jpg)  
+Figure 3: Full batch-size training of Resnet-32 for $\eta = 0 . 0 1$ and (left) $\eta = 0 . 0 5$ (right) on CIFAR-10. Evolution of the top 10 eigenvalues of the Hessian and accuracy are shown in each case. The training is unstable; an initial growth of curvature scale is followed by a sudden drop in accuracy. The CIFAR-10 dataset was subsampled to 2500 points.
+
+Learning rate and batch-size limit the maximum spectral norm. Next, we investigate how the choice of learning rate and batch size impacts the SGD path in terms of its curvatures. Fig. 4 shows the evolution of the two largest eigenvalues of the Hessian during training of the SimpleCNN and Resnet-32 on CIFAR-10, and an LSTM on PTB, for different values of $\eta$ and $S$ . We observe in this figure that a larger learning rate or a smaller batch-size correlates with a smaller and earlier peak of the spectral norm and the subsequent largest eigenvalue. Note that the phase in which curvature grows for low learning rates or large batch sizes can take many epochs. Additionally, momentum has an analogous effect – using a larger momentum leads to a smaller peak of spectral norm, see Fig. 13 in Appendix. Similar observations hold for VGG-11 and Resnet-32 using Batch-Normalization, see Appendix A.1.
+
+Summary. These results show that the learning rate and batch size not only influence the SGD endpoint maximum curvature, but also impact the whole SGD trajectory. A high learning rate or a small batch size limits the maximum spectral norm along the path found by SGD from the beginning of training. While this behavior was observed in all settings examined (see also the Appendix), future work could focus on a theoretical analysis, helping to establish the generality of these results.
+
+![](images/522d5bd2a78acc0b4bda368465fd46ce4f846e40a6670ead8c64dd17cb10da22.jpg)  
+Figure 4: Evolution of the two largest eigenvalues (solid and dashed line) of the Hessian for Resnet-32, SimpleCNN, and LSTM (trained on the PTB dataset) models on a log-scale for different learning rates (top) and batch-sizes (bottom). Blue/green/red correspond to increasing $\eta$ and decreasing $S$ in each figure. Left side of the vertical blue bar in each plot corresponds to the early phase of training. Larger learning rate or a smaller batch-size correlates with a smaller and earlier peak of the spectral norm and the next largest eigenvalue.
+
+# 3.2 Sharpest direction and SGD step
+
+The training dynamics (which later we will see affect the speed and generalization capability of learning) are significantly affected by the evolution of the largest eigenvalues discussed in Section 3.1. To demonstrate this we study the relationship between the SGD step and the loss surface shape in the sharpest directions. As we will show, SGD dynamics are largely coupled with the shape of the loss surface in the sharpest direction, in the sense that when projected onto the sharpest direction, the typical step taken by SGD is too large compared to curvature to enable it to reduce loss. We study the same SimpleCNN and Resnet-32 models as in the previous experiment in the first 6 epochs of training with SGD with $\eta { = } 0 . 0 1$ and $S = 1 2 8$ .
+
+The sharpest direction and the SGD step. First, we investigate the relation between the SGD step and the sharpest direction by looking at how the loss value changes on average when moving from the current parameters taking a step only along the sharpest direction - see Fig. 6 left. For all training iterations, we compute $\mathbb { E } [ L ( \pmb { \theta } ( t ) - \alpha \eta \tilde { \pmb { g } } _ { 1 } ( t ) ) ] - L ( \pmb { \theta } ( t ) )$ , for $\alpha \in \{ 0 . 2 5 , 0 . 5 , 1 , 2 , 4 \}$ ; the expectation is approximated by an average over 10 different mini-batch gradients. We find that $\mathbb { E } [ L ( \pmb { \theta } ( t ) - \alpha \eta \tilde { \pmb { g } } _ { 1 } ( t ) ) ]$ increases relative to $L ( \pmb \theta ( t ) )$ for $\alpha > 1$ , and decreases for $\alpha < 1$ . More specifically, for SimpleCNN we find that $\alpha = 2$ and $\alpha = 4$ lead to a $2 . 1 \%$ and $1 1 . 1 \%$ increase in loss, while $\alpha = 0 . 2 5$ and $\alpha = 0 . 5$ both lead to a decrease of approximately $2 \%$ . For Resnet-32 we observe a $3 \%$ and $1 3 . 1 \%$ increase for $\alpha = 2$ and $\alpha = 4$ , and approximately a $0 . 5 \%$ decrease for $\alpha = 0 . 2 5$ and $\alpha = 0 . 5$ , respectively. The observation that SGD step does not minimize the loss along the sharpest direction suggests that optimization is ineffective along this direction. This is also consistent with the observation that learning rate and batch-size limit the maximum spectral norm of the Hessian (as both impact the SGD step length).
+
+These dynamics are important for the overall training due to a high alignment of SGD step with the sharpest directions. We compute the average cosine between the mini-batch gradient ${ \mathbf { g } } ^ { S } ( t )$ and the top 5 sharpest directions $\mathbf { e } _ { 1 } ( t ) , \ldots . \mathbf { e } _ { 5 } ( t )$ . We find the gradient to be highly aligned with the sharpest direction, that is, depending on $\eta$ and model the maximum average cosine is roughly between 0.2 and 0.4. Full results are presented in Fig. 5.
+
+Qualitatively, SGD step crosses the minimum along the sharpest direction. Next, we qualitatively visualize the loss surface along the sharpest direction in the first few epochs of training, see Fig 6 (right). To better reflect the relation between the sharpest direction and the SGD step we scaled the visualization using the expected norm of the SGD step $\Delta \pmb { \theta } _ { 1 } ( t ) = \eta \mathbb { E } ( | \widetilde { g } _ { 1 } ( t ) | )$ where the expectation is over 10 mini-batch gradients. Specifically, we evaluate $L ( \pmb \theta ( t ) + k e _ { 1 } \overline { { \Delta \pmb \theta } } _ { 1 } ( t ) )$ , where $\pmb \theta ( t )$ is the current parameter vector, and $k$ is an interpolation parameter (we use $k \in [ - 5 , 5 ] ,$ ). For both SimpleCNN and Resnet-32 models, we observe that the loss on the scale of $\Delta \theta _ { 1 } ( t )$ starts to show a bowl-like structure in the largest eigenvalue direction after six epochs. This further corroborates the previous result that SGD step length is large compared to curvature in the sharpest direction.
+
+![](images/a00a1829c07bd232120c208e1c3c0f73ed7e71c3c5eb4210bcac1b26464d712b.jpg)  
+Figure 5: Average cosine between mini-batch gradient (y axis) and top sharpest directions (averaged over top 5) for different $\eta$ (color) evaluated at different level of accuracies, during training (x axis). For comparison, the horizontal purple line is alignment with a random vector in the parameter space. Curves were smoothed for clarity.
+
+![](images/62e1fe2175d1f73b4673903493cd60a2c3070f05afc02b20b007671efe558324.jpg)  
+Figure 6: Early on in training, SGD finds a region such that in the sharpest direction, the SGD step length is often too large compared to curvature. Experiments on SimpleCNN and Resnet32, trained with $\eta = 0 . 0 1$ , $S = 1 2 8$ , learning curves are provided in the Appendix. Left two: Average change in loss $\mathbb { E } [ L ( \pmb { \theta } ( t ) - \alpha \eta \tilde { \pmb { g } } _ { 1 } ( t ) ) ] - L ( \pmb { \theta } ( t ) )$ , for $\alpha = 0 . 5 , 1 , 2$ corresponding to red, green, and blue, respectively. On average, the SGD step length in the direction of the sharpest direction does not minimize the loss. The red points further show that increasing the step size by a factor of two leads to increasing loss (on average). Right two: Qualitative visualization of the surface along the top eigenvectors for SimpleCNN and Resnet-32 support that SGD step length is large compared to the curvature along the top eigenvector. At iteration $t$ we plot the loss $L ( \pmb \theta ( t ) + k e _ { 1 } \overline { { \Delta \pmb \theta } } _ { 1 } ( t ) )$ , around the current parameters $\pmb \theta ( t )$ , where $\Delta \theta _ { 1 } ( t )$ is the expected norm of the SGD step along the top eigenvector $e _ { 1 }$ . The $x$ -axis represents the interpolation parameter $k$ , the -axis the epoch, and the -axis the loss value, $y$ $z$ the color indicated spectral norm in the given epoch (increasing from blue to red).
+
+Training and validation accuracy are reported in Appendix B. Furthermore, in the Appendix B we demonstrate that a similar phenomena happens along the lower eigenvectors, for different $\eta$ , and in the later phase of training.
+
+Summary. We infer that SGD steers toward a region in which the SGD step is highly aligned with the sharpest directions and would on average increase the loss along the sharpest directions, if restricted to them. This in particular suggests that optimization is ineffective along the sharpest direction, which we will further study in Sec. 4.
+
+# 3.3 How SGD steers to sharp regions in the beginning
+
+Here we discuss the dynamics around the initial growth of the spectral norm of the Hessian.   
+We will look at some variants of SGD which change how the sharpest directions get optimized.
+
+![](images/70ac01a2066a9bcb9e550a63718de21aa48fb4b22ba5437e73f16523593bb2d3.jpg)  
+Figure 7: Evolution of the loss and the top eigenvalue during training with variations of SGD with parameter updates restricted to certain subspaces. All variants are initialized at the last iteration in Fig. 1. An SGD variant (orange) that follows at each iteration only the projection of the gradient on the top eigenvector of $\mathbf { H }$ effectively finds a region with lower $\lambda _ { m a x }$ but increases the loss, while a variant subtracting this projection from the gradient (red), finds a sharper region while achieving a similar loss level as vanilla SGD (blue).
+
+![](images/f478981dcd8b38da2f166d2acebf1f2fc665f74badb7e55aa91d99acd2184e1c.jpg)  
+Figure 8: Nudged-SGD for an increasing number of affected sharpest directions ( $K$ ) optimizes significantly faster, whilst generally finding increasingly sharp regions. Experiment is run using Resnet-32 and the Cifar-10 dataset. Left and center: Validation accuracy and the $\lambda _ { m a x }$ and Frobenius norm (y axis, solid and dashed) using increasing $K$ (blue to red) compared against SGD baseline using the same $\eta$ (black), during training (x axis). Rightmost: Test accuracy (red) and Frobenius norm (blue) achieved using NSGD with an increasing $K$ (x axis) compared to an SGD baseline using the same $\eta$ (blue and red horizontal lines).
+
+Experiment. We used the same SimpleCNN model initialized with the parameters reached by SGD in the previous experiment at the end of epoch 4. The parameter updates used by the three SGD variants, which are compared to vanilla SGD (blue), are based on the mini-batch gradient $\pmb { g } ^ { ( S ) }$ as follows: variant 1 (SGD top, orange) only updates the parameters based on the projection of the gradient on the top eigenvector direction, i.e. $\pmb { g } ( t ) = \langle \pmb { g } ^ { ( S ) } ( t ) , \mathbf { e } _ { 1 } ( t ) \rangle \mathbf { e } _ { 1 } ( t )$ ; variant 2 (SGD constant top, green) performs updates along the constant direction of the top eigenvector ${ \bf e } _ { 1 } ( 0 )$ of the Hessian in the first iteration, i.e. $\pmb { g } ( t ) = \langle \pmb { g } ^ { ( S ) } ( t ) , \mathbf { e } _ { 1 } ( 0 ) \rangle \mathbf { e } _ { 1 } ( 0 )$ ; variant 3 (SGD no top, red) removes the gradient information in the direction of the top eigenvector, i.e. $\pmb { g } ( t ) = \pmb { g } ^ { ( S ) } ( t ) - \langle \pmb { g } ^ { ( S ) } ( t ) , \mathbf { e } _ { 1 } ( t ) \rangle \mathbf { e } _ { 1 } ( t )$ . We show results in the left two plots of Fig. 7. We observe that if we only follow the top eigenvector, we get to wider regions but don’t reach lower loss values, and conversely, if we ignore the top eigenvector we reach lower loss values but sharper regions.
+
+Summary. The take-home message is that SGD updates in the top eigenvector direction strongly influence the overall path taken in the early phase of training. Based on these results, we will study a related variant of SGD throughout the training in the next section.
+
+# 4 Optimizing faster while finding a good sharp region
+
+In this final section we study how the convergence speed of SGD and the generalization of the resulting model depend on the dynamics along the sharpest directions.
+
+Our starting point are the results presented in Sec. 3 which show that while the SGD step can be highly aligned with the sharpest directions, on average it fails to minimize the loss if restricted to these directions. This suggests that reducing the alignment of the SGD update direction with the sharpest directions might be beneficial, which we investigate here via a variant of SGD, which we call Nudged-SGD (NSGD). Our aim here is not to build a practical optimizer, but instead to see if our insights from the previous section can be utilized in an optimizer. NSGD is implemented as follows: instead of using the standard SGD update, $\Delta \pmb { \theta } ( t ) = - \eta \pmb { g } ^ { ( S ) } ( t )$ , NSGD uses a different learning rate, $\eta ^ { \prime } = \gamma \eta$ , along just the top $K$ eigenvectors, while following the normal SGD gradient along all the others directions4. In particular we will study NSGD with a low base learning rate $\eta$ , which will allow us to capture any implicit regularization effects NSGD might have. We ran experiments with Resnet-32 and SimpleCNN on CIFAR-10. Note, that these are not state-of-the-art models, which we leave for future investigation.
+
+Table 1: Nudged-SGD optimizes faster and finds a sharper final endpoint with a slightly better generalization performance. Experiments on Resnet-32 model on the Cifar-10 dataset. Columns: the Frobenius norm of the Hessian at the best validation point and the final epoch; test accuracy; validation at epoch 50; cross-entropy loss in the final epoch; distance of the parameters from the initialization to the best validation epoch parameters. Experiments were performed with $\eta = 0 . 0 1$ and $S = 1 2 8$ . In the last rows we report SGD using $\eta \in \{ 0 . 0 0 5 , 0 . 1 \}$ .   
+
+<table><tr><td></td><td>H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>1,018/1,019</td><td>87.3%</td><td>69.3%</td><td>0.01324</td><td>21.08</td></tr><tr><td>γ = 0.1</td><td>931/929</td><td>87.2%</td><td>69.0%</td><td>0.00940</td><td>21.32</td></tr><tr><td>γ = 1.0</td><td>272/324</td><td>86.6%</td><td>63.0%</td><td>0.01719</td><td>22.90</td></tr><tr><td>γ = 5.0</td><td>111/83</td><td>85.5%</td><td>52.3%</td><td>1.17170</td><td>25.32</td></tr><tr><td>SGD(0.005)</td><td>678/946</td><td>86.0%</td><td>49.9%</td><td>0.06221</td><td>18.87</td></tr><tr><td>SGD(0.1)</td><td>24/25</td><td>88.0%</td><td>84.7%</td><td>0.00100</td><td>50.73</td></tr></table>
+
+We investigated NSGD with a different number of sharpest eigenvectors $K$ , in the range between 1 and 20; and with the rescaling factor $\gamma \in \{ 0 . 0 1 , 0 . 1 , 1 , 5 \}$ . The top eigenvectors are recomputed at the beginning of each epoch5. We compare the sharpness of the reached endpoint by both computing the Frobenius norm (approximated by the top 50 eigenvectors), and the spectral norm of the Hessian. The learning rate is decayed by a factor of 10 when validation loss has not improved for 100 epochs. Experiments are averaged over two random seeds. When talking about the generalization we will refer to the test accuracy at the best validation accuracy epoch. Results for Resnet-32 are summarized in Fig. 8 and Tab. 1; for full results on SimpleCNN we relegate the reader to Appendix, Tab. 2. In the following we will highlight the two main conclusions we can draw from the experimental data.
+
+NSGD optimizes faster, whilst traversing a sharper region. First, we observe that in the early phase of training NSGD optimizes significantly faster than the baseline, whilst traversing a region which is an order of magnitude sharper. We start by looking at the impact of $K$ which controls the amount of eigenvectors with adapted learning rate; we test $K$ in $\{ 1 , \ldots , 2 0 \}$ with a fixed $\gamma = 0 . 0 1$ . On the whole, increasing $K$ correlates with a significantly improved training speed and visiting much sharper regions (see Fig. 8). We highlight that NSGD with $K = 2 0$ reaches a maximum $\lambda _ { m a x }$ of approximately $8 \cdot 1 0 ^ { 3 }$ compared to baseline SGD reaching approximately 150. Further, NSGD retains an advantage of over 5% ( $1 \%$ for SimpleCNN) validation accuracy, even after 50 epochs of training (see Tab. 1).
+
+NSGD can improve the final generalization performance, while finding a sharper final region. Next, we turn our attention to the results on the final generalization and sharpness. We observe from Tab. 1 that using $\gamma < 1$ can result in finding a significantly sharper endpoint exhibiting a slightly improved generalization performance compared to baseline SGD using the same $\eta = 0 . 0 1$ . On the contrary, using $\gamma > 1$ led to a wider endpoint and a worse generalization, perhaps due to the added instability. Finally, using a larger $K$ generally correlates with an improved generalization performance (see Fig. 8, right).
+
+More specifically, baseline SGD using the same learning rate reached $8 6 . 4 \%$ test accuracy with the Frobenius norm of the Hessian $| | \mathbf { H } | | _ { F } = 2 7 2$ ( $8 6 . 6 \%$ with $| | \mathbf { H } | | _ { F } = 1 9 1$ on SimpleCNN). In comparison, NSGD using $\gamma = 0 . 0 1$ found endpoint corresponding to $8 7 . 0 \%$ test accuracy and $| | \mathbf { H } | | _ { F } = 1 0 1 8$ (87.4% and $| | \mathbf { H } | | _ { F } = 2 8 7$ on SimpleCNN). Finally, note that in the case of Resnet-32 $K = 2 0$ leads to $8 8 \%$ test accuracy and $| | \mathbf { H } | | _ { F } = 1 1 0 0$ which closes the generalization gap to SGD using $\eta = 0 . 1$ . We note that runs corresponding to $\eta = 0 . 0 1$ generally converge at final cross-entropy loss around 0.01 and over $9 9 \%$ training accuracy.
+
+As discussed in Sagun et al. (2017) the structure of the Hessian can be highly dataset dependent, thus the demonstrated behavior of NSGD could be dataset dependent as well. In particular NSGD impact on the final generalization can be dataset dependent. In the Appendix C and Appendix F we include results on the CIFAR-100, Fashion MNIST (Xiao et al., 2017) and IMDB (Maas et al., 2011) datasets, but studies on more diverse datasets are left for future work. In these cases we observed a similar behavior regarding faster optimization and steering towards sharper region, while generalization of the final region was not always improved. Finally, we relegate to the Appendix C additional studies using a high base learning and momentum.
+
+Summary. We have investigated what happens if SGD uses a reduced learning rate along the sharpest directions. We show that this variant of SGD, i.e. NSGD, steers towards sharper regions in the beginning. Furthermore, NSGD is capable of optimizing faster and finding good generalizing sharp minima, i.e. regions of the loss surface at the convergence which are sharper compared to those found by vanilla SGD using the same low learning rate, while exhibiting better generalization performance. Note that in contrast to Dinh et al. (2017) the sharp regions that we investigate here are the endpoints of an optimization procedure, rather than a result of a mathematical reparametrization.
+
+# 5 Related work
+
+Tracking the Hessian: The largest eigenvalues of the Hessian of the loss of DNNs were investigated previously but mostly in the late phase of training. Some notable exceptions are: LeCun et al. (1998) who first track the Hessian spectral norm, and the initial growth is reported (though not commented on). Sagun et al. (2016) report that the spectral norm of the Hessian reduces towards the end of training. Keskar et al. (2016) observe that a sharpness metric grows initially for large batch-size, but only decays for small batch-size. Our observations concern the eigenvalues and eigenvectors of the Hessian, which follow the consistent pattern, as discussed in Sec. 3.1. Finally, Yao et al. (2018) study the relation between the Hessian and adversarial robustness at the endpoint of training.
+
+Wider minima generalize better: Hochreiter and Schmidhuber (1997) argued that wide minima should generalize well. Keskar et al. (2016) provided empirical evidence that the width of the endpoint minima found by SGD relates to generalization and the used batch-size. Jastrzębski et al. (2017) extended this by finding a correlation of the width and the learning rate to batch-size ratio. Dinh et al. (2017) demonstrated the existence of reparametrizations of networks which keep the loss value and generalization performance constant while increasing sharpness of the associated minimum, implying it is not just the width of a minimum which determines the generalization. Recent work further explored importance of curvature for generalization (Wen et al., 2018; Wang et al., 2018).
+
+Stochastic gradient descent dynamics. Our work is related to studies on SGD dynamics such as Goodfellow et al. (2014); Chaudhari and Soatto (2017); Xing et al. (2018); Zhu et al. (2018). In particular, recently Zhu et al. (2018) investigated the importance of noise along the top eigenvector for escaping sharp minima by comparing at the final minima SGD with other optimizer variants. In contrast we show that from the beginning of training SGD visits regions in which SGD step is too large compared to curvature. Concurrent with this work Xing et al. (2018) by interpolating the loss between parameter values at consecutive iterations show it is roughly-convex, whereas we show a related phenomena by investigating the loss in the subspace of the sharpest directions of the Hessian.
+
+# 6 Conclusions
+
+The somewhat puzzling empirical correlation between the endpoint curvature and its generalization properties reached in the training of DNNs motivated our study. Our main contribution is exposing the relation between SGD dynamics and the sharpest directions, and investigating its importance for training. SGD steers from the beginning towards increasingly sharp regions of the loss surface, up to a level dependent on the learning rate and the batch-size. Furthermore, the SGD step is large compared to the curvature along the sharpest directions, and highly aligned with them.
+
+Our experiments suggest that understanding the behavior of optimization along the sharpest directions is a promising avenue for studying generalization properties of neural networks. Additionally, results such as those showing the impact of the SGD step length on the regions visited (as characterized by their curvature) may help design novel optimizers tailor-fit to neural networks.
+
+# Acknowledgements
+
+SJ was supported by grant No. DI 2014/016644 from Ministry of Science and Higher Education, Poland. SJ also received funding from projects No. 2017/25/B/ST6/01271 and No. 2017/24/T/ST6/00487 from National Science Center, Poland. Work at Mila was funded by NSERC, CIFAR, and Canada Research Chairs. This project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No 732204 (Bonseyes). This work is supported by the Swiss State Secretariat for Education‚ Research and Innovation (SERI) under contract number 16.0159.
+
+# References
+
+Madhu S Advani and Andrew M Saxe. High-dimensional dynamics of generalization error in neural networks. arXiv preprint arXiv:1710.03667, 2017.
+
+J. Bjorck, C. Gomes, and B. Selman. Understanding Batch Normalization. ArXiv e-prints, May 2018.
+
+P. Chaudhari and S. Soatto. Stochastic gradient descent performs variational inference, converges to limit cycles for deep networks. ArXiv e-prints, October 2017.
+
+François Chollet et al. Keras. https://github.com/keras-team/keras, 2015.
+
+Yann Dauphin, Razvan Pascanu, Çaglar Gülçehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. CoRR, abs/1406.2572, 2014. URL http://arxiv.org/abs/ 1406.2572.
+
+Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv preprint arXiv:1703.04933, 2017.
+
+I. J. Goodfellow, O. Vinyals, and A. M. Saxe. Qualitatively characterizing neural network optimization problems. ArXiv e-prints, December 2014.
+
+Priya Goyal, Piotr Dollár, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017.
+
+Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997.
+
+Stanisław Jastrzębski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos Storkey. Three factors influencing minima in sgd. arXiv preprint arXiv:1711.04623, 2017.
+
+N.S.= Keskar, D. Mudigere, J. Nocedal, M. Smelyanskiy, and P. T. P. Tang. On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima. ArXiv e-prints, September 2016.
+
+Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/\~kriz/cifar.html.
+
+Cornelius Lanczos. An iteration method for the solution of the eigenvalue problem of linear differential and integral operators. J. Res. Natl. Bur. Stand. B, 45:255–282, 1950. doi: 10.6028/jres.045.026.
+
+Yann LeCun, Léon Bottou, Genevieve B. Orr, and Klaus-Robert Müller. Efficient backprop. In Neural Networks: Tricks of the Trade, This Book is an Outgrowth of a 1996 NIPS Workshop, pages 9–50, London, UK, UK, 1998. Springer-Verlag. ISBN 3-540-65311-2. URL http://dl.acm.org/citation.cfm?id=645754.668382.
+
+Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies - Volume 1, HLT ’11, pages 142–150, Stroudsburg, PA, USA, 2011. Association for Computational Linguistics. ISBN 978-1-932432-87-9. URL http://dl.acm.org/ citation.cfm?id=2002472.2002491.
+
+Noboru Murata, Shuji Yoshizawa, and Shun ichi Amari. Network information criteriondetermining the number of hidden units for an artificial neural network model. IEEE transactions on neural networks, 5 6:865–72, 1994.
+
+Behnam Neyshabur, Srinadh Bhojanapalli, David McAllester, and Nathan Srebro. Exploring generalization in deep learning. CoRR, abs/1706.08947, 2017. URL http://arxiv.org/ abs/1706.08947.
+
+Tomaso Poggio, Kenji Kawaguchi, Qianli Liao, Brando Miranda, Lorenzo Rosasco, Xavier Boix, Jack Hidary, and Hrushikesh Mhaskar. Theory of deep learning iii: explaining the non-overfitting puzzle. arXiv preprint arXiv:1801.00173, 2017.
+
+Levent Sagun, Léon Bottou, and Yann LeCun. Singularity of the hessian in deep learning. arXiv preprint arXiv:1611.07476, 2016.
+
+Levent Sagun, Utku Evci, V Ugur Guney, Yann Dauphin, and Leon Bottou. Empirical analysis of the hessian of over-parametrized neural networks. arXiv preprint arXiv:1706.04454, 2017.
+
+Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556.
+
+Masato Taki. Deep residual networks and weight initialization. CoRR, abs/1709.02956, 2017. URL http://arxiv.org/abs/1709.02956.
+
+H. Wang, N. Keskar, C. Xiong, and R. Socher. Identifying Generalization Properties in Neural Networks. ArXiv e-prints, September 2018.
+
+W. Wen, Y. Wang, F. Yan, C. Xu, C. Wu, Y. Chen, and H. Li. SmoothOut: Smoothing Out Sharp Minima to Improve Generalization in Deep Learning. ArXiv e-prints, May 2018.
+
+Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. 2017.
+
+H. Xiao, K. Rasul, and R. Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. ArXiv e-prints, August 2017.
+
+C. Xing, D. Arpit, C. Tsirigotis, and Y. Bengio. A Walk with SGD. ArXiv e-prints, February 2018.   
+Zhewei Yao, Amir Gholami, Qi Lei, Kurt Keutzer, and Michael W Mahoney. Hessianbased analysis of large batch training and robustness to adversaries. arXiv preprint arXiv:1802.08241, 2018.   
+Wojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization, 2014. URL https://arxiv.org/abs/1409.2329.   
+Chiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.   
+Z. Zhu, J. Wu, B. Yu, L. Wu, and J. Ma. The Regularization Effects of Anisotropic Noise in Stochastic Gradient Descent. ArXiv e-prints, February 2018.
+
+# A Additional results for Sec. 3.1
+
+A.1 Additional results on the evolution of the largest eigenvalues of the Hessian
+
+First, we show that the instability in the early phase of full-batch training is partially solved through use of Batch-Normalization layers, consistent with the results reported by Bjorck et al. (2018); results are shown in Fig. 9.
+
+![](images/41723527114f7efa78bbfa9b0948ab636b724ce663a7613689f989b84f83b0b2.jpg)  
+Figure 9: Full-batch training with Batch-Normalization is more stable. Evolution of the top 10 eigenvalues of the Hessian, and accuracy, for Resnet-32 trained on the CIFAR-10 dataset with $\eta = 0 . 0 1$ (left) and $\eta = 0 . 0 5$ (right).
+
+Next, we extend results of Sec. 3.1 to VGG-11 and Batch-Normalized Resnet-32 models, see Fig. 11 and Fig. 10. Importantly, we evaluated the Hessian in the inference mode, which resulted in large absolute magnitudes of the eigenvalues on Resnet-32.
+
+![](images/7c664de8ff7a8992af176f3c0852acb792ab6c9f8c71d648a63d3b28cd0b5330.jpg)  
+Figure 10: Same as Fig. 4, but for the VGG-11 architecture.
+
+![](images/bdcf296817cad447992f1f09319e31002f7c321a54fc38ec098fd2d9d72e76db.jpg)  
+Figure 11: Same as Fig. 4, but for Resnet-32 architecture using Batch-Normalization layers.
+
+# A.2 Impact of learning rate schedule
+
+In the paper we focused mostly on SGD using a constant learning rate and batch-size. We report here the evolution of the spectral and Frobenius norm of the Hessian when using a simple learning rate schedule in which we vary the length of the first stage $L$ ; we use $\eta = 0 . 1$ for $L$ epochs and drop it afterwards to $\eta = 0 . 0 1$ . We test $L$ in $\{ 1 0 , 2 0 , 4 0 , 8 0 \}$ . Results are reported in Fig. 12. The main conclusion is that depending on the learning rate schedule in the next stages of training curvature along the sharpest directions (measured either by the spectral norm, or by the Frobenius norm) can either decay or grow. Training for a shorter time (a lower $L$ ) led to a growth of curvature (in term of Frobenius norm and spectral norm) after the learning drop, and a lower final validation accuracy.
+
+![](images/d3114aefe1309905907df798eac56eb7b3d8aef35352f28ba5d1056f6d4838e7.jpg)  
+Figure 12: Depending on the length of the first stage of a learning rate schedule, spectral norm of the Hessian and generalization performance evolve differently. Left: Spectral norm of the Hessian (solid) and Frobenius norm (dashed), during training (x axis). Center: Accuracy and validation accuracy, during training (x axis). Right: Learning rate, during training (x axis).
+
+# A.3 Impact of using momentum
+
+In the paper we focused mostly on experiments using plain SGD, without momentum. In this section we report that large momentum similarly to large $\eta$ leads to a reduction of spectral norm of the Hessian, see Fig. 13 for results on the VGG11 network on CIFAR10 and CIFAR100.
+
+![](images/df2ac8aa0d130438e18fac56a3c3f21b8d2f4f62e184b03e9070076154404c31.jpg)  
+Figure 13: Momentum limits the maximum spectral norm of the Hessian throughout training. Training at $\eta = 0 . 1$ and $S = 1 2 8$ on VGG11 and CIFAR10 (left) and CIFAR100 (right).
+
+# B Additional results for Sec. 3.2
+
+In Fig. 14 we report the corresponding training and validation curves for the experiments depicted in Fig. 6. Next, we plot an analogous visualization as in Fig. 6, but for the 3rd and 5th eigenvector, see Fig. 15 and Fig. 16, respectively. To ensure that the results do not depend on the learning rate, we rerun the Resnet-32 and SimpleCNN experiments with $\eta = 0 . 0 5$ , see Fig. 17.
+
+Finally, we run the same experiment as in Sec. 3.2, but instead of focusing on the early phase we replot Fig. 6 for the first 200 epochs, see Fig. 18
+
+![](images/ea2f09838b66615f4b3cff0618574553bea35687e3dc19d056303b31107b79ab.jpg)  
+Figure 14: Training and validation accuracy for experiments in Fig 6. Left corresponds to SimpleCNN. Right corresponds to Resnet-32.
+
+![](images/9e7aecda0593871d15f2a9425bc8b7f478a5ed29ece05517fb59df0d6b89ff65.jpg)  
+Figure 15: Similar to Fig 6 but computed for the third eigenvector of the Hessian. We see that the loss surface is much flatter in this direction. To facilitate a direct comparison, scale of each axis is kept the same as in Fig. 6.
+
+![](images/6583f9f931606570e5c518e09b9442f98a11e8ae6cb5e95e3408647e0577f992.jpg)  
+Figure 16: Similar to $\mathrm { F i g ~ 6 ~ }$ but for the fourth eigenvector. We see that the loss surface is much flatter in this direction. To facilitate a direct comparison, scale of each axis is kept the same as in Fig. 6.
+
+![](images/715094b9e1836f3ac90e5d2dbd8e1068adef70f300da19fa51191549bb48d2c2.jpg)  
+Figure 17: Similar to Fig 6 but for Resnet-32 (top) and SimpleCNN (bottom) with $\eta = 0 . 0 5$ .
+
+![](images/05b650e721742b7412c7ed476ab15c20502a68b550245cd35ce553a27c0cb5b5.jpg)  
+Figure 18: Similar to Fig 6 but for Resnet-32 (top) and SimpleCNN (bottom) run for 200 epochs.
+
+# C Additional results for Sec. 4
+
+Here we report additional results for Sec. 4. Most importantly, in Tab. 2 we report full results for SimpleCNN model. Next, we rerun the same experiment, using the Resnet-32 model, on the CIFAR-100 dataset, see Tab. 5, and on the Fashion-MNIST dataset, see Tab. 6. In the case of CIFAR-100 we observe that conclusion carry-over fully. In the case of Fashion-MNIST we observe that the final generalization for the case of $\gamma < 1$ and $\gamma = 1 . 0$ is similar. Therefore, as discussed in the main text, the behavior seems to be indeed dataset dependent.
+
+![](images/fc870a05dc339849e38391eee5f2b373c2b2cec256690ed49ff22a22b1451f16.jpg)  
+Figure 19: Evolution of the spectral norm and Frobenius norm of the Hessian (y axis, solid and dashed line, respectively) for different $\gamma$ (color) for the experiment using a larger learning (left) and momentum (right), see text for details.
+
+In Sec. 4 we purposedly explored NSGD in the context of suboptimally picked learning rate, which allowed us to test if NSGD has any implicit regularization effect. In the next two experiments we explored how NSGD performs when using either a large base learning $\eta$ , or when using momentum. Results are reported in Tab. 3 (learning rate $\eta = 0 . 1$ ) and Tab. 4 (momentum $\mu = 0 . 9$ ). In both cases we observe that NSGD improves training speed and reaches a significantly sharper region initially, see Fig. 22. However, the final region curvature in both cases, and the final generalization when using momentum, is not significantly affected. Further study of NSGD using a high learning rate or momentum is left for future work.
+
+Table 2: Same as Tab. 1, but for Simple-CNN model. NSGD with $\gamma = 5 . 0$ diverged and was excluded from the Table.   
+
+<table><tr><td></td><td>||H||F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>423/429</td><td>87.1%</td><td>83.5%</td><td>0.00143</td><td>17.63</td></tr><tr><td>γ=0.1</td><td>294/268</td><td>87.4%</td><td>83.3%</td><td>0.00126</td><td>17.98</td></tr><tr><td>γ = 1.0</td><td>127/127</td><td>86.6%</td><td>82.3%</td><td>0.00063</td><td>19.76</td></tr><tr><td>γ = 5.0</td><td>130/129</td><td>85.2%</td><td>79.8%</td><td>0.00160</td><td>20.26</td></tr><tr><td>SGD(0.005)</td><td>476/516</td><td>85.8%</td><td>78.0%</td><td>0.00862</td><td>14.94</td></tr><tr><td>SGD(0.05)</td><td>34/26</td><td>87.4%</td><td>85.1%</td><td>0.00008</td><td>35.38</td></tr></table>
+
+Table 3: Same as Tab. 1, but for Resnet-32 and NSGD using base learning rate $\eta = 0 . 1$ NSGD with $\gamma = 5 . 0$ diverged and was excluded from the Table.   
+
+<table><tr><td></td><td>|H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>32/34</td><td>89.3%</td><td>85.8%</td><td>0.00322</td><td>49.04</td></tr><tr><td>γ=0.1</td><td>20/26</td><td>89.2%</td><td>85.9%</td><td>0.00105</td><td>50.73</td></tr><tr><td>γ = 1.0</td><td>25/19</td><td>87.9%</td><td>83.2%</td><td>0.00246</td><td>50.70</td></tr></table>
+
+Table 4: Same as Tab. 1, but for Resnet-32 and NSGD using momentum coefficient 0.9.   
+
+<table><tr><td></td><td>|H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>20/20</td><td>89.4%</td><td>86.9%</td><td>0.00225</td><td>47.57</td></tr><tr><td>γ=0.1</td><td>36/32</td><td>89.3%</td><td>87.1%</td><td>0.00082</td><td>47.14</td></tr><tr><td>γ = 1.0</td><td>27/34</td><td>89.2%</td><td>85.8%</td><td>0.00239</td><td>49.57</td></tr><tr><td>γ=5.0</td><td>35/44</td><td>88.2%</td><td>83.9%</td><td>0.00438</td><td>51.07</td></tr></table>
+
+Table 5: Same as Tab. 1, but for Simple-CNN and NSGD on the Fashion-MNIST dataset.   
+
+<table><tr><td></td><td>|H|F</td><td>Test acc.</td><td>Val. acc. （(50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>294/431</td><td>92.6%</td><td>90.3%</td><td>0.05300</td><td>13.73</td></tr><tr><td>γ = 0.1</td><td>257/341</td><td>92.4%</td><td>90.1%</td><td>0.04340</td><td>13.62</td></tr><tr><td>γ = 1.0</td><td>159/162</td><td>92.5%</td><td>89.8%</td><td>0.04672</td><td>14.85</td></tr><tr><td>γ= 5.0</td><td>75/101</td><td>91.7%</td><td>89.2%</td><td>0.07820</td><td>14.65</td></tr></table>
+
+Table 6: Same as Tab. 1, but for Resnet-32 and NSGD on the CIFAR-100 dataset.   
+
+<table><tr><td></td><td>||H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>1,315/1,544</td><td>56.9%</td><td>27.8%</td><td>0.18048</td><td>31.37</td></tr><tr><td>γ=0.1</td><td>797/1,192</td><td>57.4%</td><td>27.0%</td><td>0.29081</td><td>31.18</td></tr><tr><td>γ = 1.0</td><td>470/720</td><td>54.1%</td><td>25.6%</td><td>0.28299</td><td>32.67</td></tr><tr><td>γ= 5.0</td><td>240/378</td><td>53.2%</td><td>20.6%</td><td>0.51348</td><td>34.20</td></tr></table>
+
+# D SimpleCNN Model
+
+The SimpleCNN used in this paper has four convolutional layers. The first two have 32 filters, while the third and fourth have 64 filters. In all convolutional layers, the convolutional kernel window size used is (3,3) and ‘same’ padding is used. Each convolutional layer is followed by a ReLU activation function. Max-pooling is used after the second and fourth convolutional layer, with a pool-size of (2,2). After the convolutional layers there are two linear layers with output size 128 and 10 respectively. After the first linear layer ReLU activation is used. After the final linear layer a softmax is applied. Please also see the provided code.
+
+# E Comparing NSGD to Newton Method
+
+Nudged-SGD is a second order method, in the sense that it leverages the curvature of the loss surface. In this section we argue that it is significantly different from the Newton method, a representative second order method.
+
+The key reason for that is that, similarly to SGD, NSGD is driven to a region in which curvature is too large compared to its typical step. In other words NSGD does not use an optimal learning rate for the curvature, which is the key design principle for second order methods. This is visible in Fig. 20, where we report results of a similar study as in Sec. 3.2, but for NSGD ( $K = 5$ , $\gamma = 0 . 0 1$ ). The loss surface appears sharper in this plot, because reducing gradients along the top $K$ sharpest directions allows optimizing over significantly sharper regions.
+
+As discussed, the key difference stems for the early bias of SGD to reach maximally sharp regions. It is therefore expected that in case of a quadratic loss surface Newton and NSGD optimizers are very similar. In the following we construct such an example. First, recall that update in Newton method is typically computed as:
+
+$$
+\pmb \theta ( t + 1 ) = \pmb \theta ( t ) - \eta ( H + \lambda I ) ^ { - 1 } \boldsymbol g ^ { S } ( \pmb \theta ( t ) ) ,
+$$
+
+where $\lambda$ is a scalar. Now, if we assume that $H$ is diagonal and put $d i a g ( H ) \ =$ $[ 1 0 0 , 1 0 0 , 1 0 0 , 1 0 0 , 1 0 0 , 1 , 1 ]$ , and finally let $\lambda = 0$ , it can be seen that the update of NSGD with $\gamma = 0 . 0 1$ and $K = 5$ is equivalent to that of Newton method.
+
+![](images/7b4b332909e5c367a108fb7152e64ed8a46960d1edd628f8f6fa7c6ec5d4dda7.jpg)  
+Figure 20: Same as Fig. 6, but for NSGD with $\gamma = 0 . 0 1$ and $K = 5$ .
+
+# F Experiments on sentiment analysis dataset
+
+Most of the experiments in the paper focused on image classification datasets (except for language modeling experiments in Sec. 3.1). The goal of this section is to extend some of the experiments to the text domain. We experiment with the IMDB (Maas et al., 2011) binary sentiment classification dataset and use the simple CNN model from the Keras (Chollet et al., 2015) example repository6.
+
+First, we examine the impact of learning rate and batch-size on the Hessian along the training trajectory as in Sec. 3.1. We test $\eta \in \{ 0 . 0 2 5 , 0 . 0 5 , 0 . 1 \}$ and $S \in \{ 2 , 8 , 3 2 \}$ . As in Sec. 3.1 we observe that the learning rate and the batch-size limit the maximum curvature along the training trajectory. In this experiment the phase in which the curvature grows took many epochs, in contrast to the CIFAR-10 experiments. The results are summarized in Fig. 21.
+
+Next, we tested Nudged SGD with $\eta = 0 . 0 1$ , $S = 8$ and $K = 1$ . We test $\gamma \in \{ 0 . 1 , 1 . 0 , 5 . 0 \}$ . We increased the number of parameters of the base model by increasing by a factor of 2 number of filters in the first convolutional layer and the number of neurons in the dense layer to encourage overfitting. Experiments were repeated over 3 seeds.
+
+We observe that in this setting NSGD for $\gamma < 1$ optimizes significantly faster and finds a sharper region initially. At the same time using $\gamma < 1$ does not result in finding a better generalizing region. The results are summarized in Tab. 7 and Fig. 22.
+
+![](images/de17dffd2f01bb5f3f9761286028a745b45652f9b439321b6b2ac5d9768dc85c.jpg)  
+Figure 21: Same as Fig. 4, but for CNN model on the IMDB dataset.
+
+![](images/58c44cbcfd3c6722f3b8e492c6b6e903f2382e45623c1b9637519b5504a92c51.jpg)  
+Figure 22: NSGD experiments on IMDB dataset. Evolution of the validation accuracy (left) and spectral norm of the Hessian (left) for different $\gamma$ .
+
+Table 7: Same as Tab. 1, but for CNN on IMDB dataset.   
+
+<table><tr><td></td><td>H|F</td><td>Test acc.</td><td>Val. acc. (10)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ=0.1</td><td>5.91/1.94</td><td>88.83%</td><td>86.79</td><td>0.00031</td><td>13.24</td></tr><tr><td>γ = 1.0</td><td>4.19/1.45</td><td>88.79%</td><td>84.52</td><td>0.00029</td><td>14.04</td></tr><tr><td>γ =5.0</td><td>2.36/0.79</td><td>88.37%</td><td>78.32</td><td>0.00023</td><td>16.85</td></tr></table>

parse/train/SkgEaj05t7/SkgEaj05t7_content_list.json

@@ -0,0 +1,1732 @@
+[
+    {
+        "type": "text",
+        "text": "On the relation between the sharpest directions of DNN loss and the SGD step length ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            101,
+            825,
+            147
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stanisław Jastrzębsk $^ { 1 , 2 }$ , Zachary Kenton $^ 2$ , Nicolas Ballas $^ 3$ , Asja Fischer $^ 4$ , Yoshua Bengio $^ { 2 , 5 }$ , and Amos Storkey6 ",
+        "bbox": [
+            174,
+            174,
+            823,
+            204
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1Jagiellonian University $^ 2$ Mila / University of Montreal 3Facebook AI Research $^ 4$ Ruhr University Bochum $^ 5$ CIFAR Senior Fellow $^ 6$ School of Informatics, University of Edinburgh ",
+        "bbox": [
+            328,
+            217,
+            669,
+            300
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            452,
+            340,
+            545,
+            357
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Stochastic Gradient Descent (SGD) based training of neural networks with a large learning rate or a small batch-size typically ends in well-generalizing, flat regions of the weight space, as indicated by small eigenvalues of the Hessian of the training loss. However, the curvature along the SGD trajectory is poorly understood. An empirical investigation shows that initially SGD visits increasingly sharp regions, reaching a maximum sharpness determined by both the learning rate and the batch-size of SGD. When studying the SGD dynamics in relation to the sharpest directions in this initial phase, we find that the SGD step is large compared to the curvature and commonly fails to minimize the loss along the sharpest directions. Furthermore, using a reduced learning rate along these directions can improve training speed while leading to both sharper and better generalizing solutions compared to vanilla SGD. In summary, our analysis of the dynamics of SGD in the subspace of the sharpest directions shows that they influence the regions that SGD steers to (where larger learning rate or smaller batch size result in wider regions visited), the overall training speed, and the generalization ability of the final model. ",
+        "bbox": [
+            233,
+            375,
+            764,
+            609
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            640,
+            339,
+            656
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep Neural Networks (DNNs) are often massively over-parameterized (Zhang et al., 2016), yet show state-of-the-art generalization performance on a wide variety of tasks when trained with Stochastic Gradient Descent (SGD). While understanding the generalization capability of DNNs remains an open challenge, it has been hypothesized that SGD acts as an implicit regularizer, limiting the complexity of the found solution (Poggio et al., 2017; Advani and Saxe, 2017; Wilson et al., 2017; Jastrzębski et al., 2017). ",
+        "bbox": [
+            174,
+            672,
+            823,
+            756
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Various links between the curvature of the final minima reached by SGD and generalization have been studied (Murata et al., 1994; Neyshabur et al., 2017). In particular, it is a popular view that models corresponding to wide minima of the loss in the parameter space generalize better than those corresponding to sharp minima (Hochreiter and Schmidhuber, 1997; Keskar et al., 2016; Jastrzębski et al., 2017; Wang et al., 2018). The existence of this empirical correlation between the curvature of the final minima and generalization motivates our study. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            847
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Our work aims at understanding the interaction between SGD and the sharpest directions of the loss surface, i.e. those corresponding to the largest eigenvalues of the Hessian. In contrast to studies such as those by Keskar et al. (2016) and Jastrzębski et al. (2017) our analysis focuses on the whole training trajectory of SGD rather than just on the endpoint. We will show in Sec. 3.1 that the evolution of the largest eigenvalues of the Hessian follows a consistent pattern for the different networks and datasets that we explore. Initially, SGD is in a region of broad curvature, and as the loss decreases, SGD visits regions in which the top eigenvalues of the Hessian are increasingly large, reaching a peak value with a magnitude influenced by both learning rate and batch size. After that point in training, we typically observe a decrease or stabilization of the largest eigenvalues. ",
+        "bbox": [
+            174,
+            854,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/af3b010f678c94c04a8ccab7fe1028e5d324e84be04e1b879a329efe0c14e1fa.jpg",
+        "image_caption": [
+            "Figure 1: Left: Outline of the phenomena discussed in the paper. Curvature along the sharpest direction(s) initially grows (A to C). In most iterations, we find that SGD crosses the minimum if restricted to the subspace of the sharpest direction(s) by taking a too large step (B and C). Finally, curvature stabilizes or decays with a peak value determined by learning rate and batch size (C, see also right). Right two: Representative example of the evolution of the top 30 (decreasing, red to blue) eigenvalues of the Hessian for a SimpleCNN model during training (with $\\eta = 0 . 0 0 5$ , note that $\\eta$ is close to $\\begin{array} { r } { \\frac { 1 } { \\lambda _ { m a x } } = \\frac { 1 } { 1 6 0 } } \\end{array}$ 1160 ). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            246,
+            99,
+            750,
+            210
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            349,
+            823,
+            419
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To further understand this phenomenon, we study the dynamics of SGD in relation to the sharpest directions in Sec. 3.2 and Sec. 3.3. Projecting to the sharpest directions1, we see that the regions visited in the beginning resemble bowls with curvatures such that an SGD step is typically too large, in the sense that an SGD step cannot get near the minimum of this bowl-like subspace; rather it steps from one side of the bowl to the other, see Fig. 1 for an illustration. ",
+        "bbox": [
+            174,
+            426,
+            825,
+            510
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Finally in Sec. 4 we study further practical consequences of our observations and investigate an SGD variant which uses a reduced and fixed learning rate along the sharpest directions. In most cases we find this variant optimizes faster and leads to a sharper region, which generalizes the same or better compared to vanilla SGD with the same (small) learning rate. While we are not proposing a practical optimizer, these results may open a new avenue for constructing effective optimizers tailored to the DNNs’ loss surface in the future. ",
+        "bbox": [
+            174,
+            517,
+            825,
+            599
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "On the whole this paper exposes and analyses SGD dynamics in the subspace of the sharpest directions. In particular, we argue that the SGD dynamics along the sharpest directions influence the regions that SGD steers to (where larger learning rate or smaller batch size result in wider regions visited), the training speed, and the final generalization capability. ",
+        "bbox": [
+            176,
+            607,
+            825,
+            662
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 Experimental setup and notation ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            686,
+            544,
+            702
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We perform experiments mainly on Resnet- $3 2 ^ { 2 }$ and a simple convolutional neural network, which we refer to as SimpleCNN (details in the Appendix D), and the CIFAR-10 dataset (Krizhevsky et al.). SimpleCNN is a 4 layer CNN, achieving roughly $8 6 \\%$ test accuracy on the CIFAR-10 dataset. For training both of the models we use standard data augmentation on CIFAR-10 and for Resnet-32 L2 regularization with coefficient 0.005. We additionally investigate the training of VGG-11 (Simonyan and Zisserman, 2014) on the CIFAR-10 dataset (we adapted the final classification layers for 10 classes) and of a bidirectional Long Short Term Memory (LSTM) model (following the “small” architecture employed by Zaremba et al. (2014), with added dropout regularization of 0.1) on the Penn Tree Bank (PTB) dataset. All models are trained using SGD, without using momentum, if not stated otherwise. ",
+        "bbox": [
+            173,
+            717,
+            825,
+            843
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/d6bf8efa1856dce311c9fa72c0cc48588f6f4e5bb4fa7802e129a0890f4487dd.jpg",
+        "image_caption": [
+            "Figure 2: Top: Evolution of the top 10 eigenvalues of the Hessian for SimpleCNN and Resnet-32 trained on the CIFAR-10 dataset with $\\eta = 0 . 1$ and $S = 1 2 8$ . Bottom: Zoom on the evolution of the top 10 eigenvalues in the beginning of training. A sharp initial growth of the largest eigenvalues followed by an oscillatory-like evolution is visible. Training and test accuracy of the corresponding models are provided for reference. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            98,
+            812,
+            297
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            411,
+            821,
+            440
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The notation and terminology we use in this paper are now described. We will use $t$ (time) to refer to epoch or iteration, depending on the context. By and $S$ we denote $\\eta$ the SGD learning rate and batch size, respectively. $\\mathbf { H }$ is the Hessian of the empirical loss at the current $D$ -dimensional parameter value evaluated on the training set, and its eigenvalues are denoted as $\\lambda _ { i }$ , $i = 1 \\ldots D$ (ordered by decreasing absolute magnitudes). $\\lambda _ { m a x } { = \\lambda _ { 1 } }$ is the maximum eigenvalue, which is equivalent to the spectral norm of $\\mathbf { H }$ . The top $K$ eigenvectors of $\\mathbf { H }$ are denoted by $e _ { i }$ , for $i \\in \\{ 1 , \\ldots , K \\}$ , and referred to in short as the sharpest directions. We will refer to the mini-batch gradient calculated based on a batch of size $S$ as $\\mathbf { \\pmb { g } } ^ { ( S ) } ( t )$ and to ${ \\eta } { \\pmb g } ^ { ( S ) } ( t )$ as the $S G D$ step. We will often consider the projection of this gradient onto one of the top eigenvectors, given by $\\tilde { \\mathbf { g } } _ { i } ( t ) = \\tilde { g } _ { i } ( t ) e _ { i } ( t )$ , where $\\tilde { g } _ { i } ( t ) \\equiv \\langle \\pmb { g } ^ { ( S ) } ( t ) , \\pmb { e } _ { i } ( t ) \\rangle$ . Computing the full spectrum of the Hessian $\\mathbf { H }$ for reasonably large models is computationally infeasible. Therefore, we approximate the top $K$ (up to 50) eigenvalues using the Lanczos algorithm (Lanczos, 1950; Dauphin et al., 2014), an extension of the power method, on approximately $5 \\%$ of the training data (using more data was not beneficial). When regularization was applied during training (such as dropout, L2 or data augmentation), we apply the same regularization when estimating the Hessian. This ensures that the Hessian reflects the loss surface accessible to SGD. The code for the project is made available at https://github.com/kudkudak/dnn_sharpest_directions. ",
+        "bbox": [
+            173,
+            446,
+            825,
+            699
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 A study of the Hessian along the SGD path ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            724,
+            648,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we study the eigenvalues of the Hessian of the training loss along the SGD optimization trajectory, and the SGD dynamics in the subspace corresponding to the largest eigenvalues. We highlight that SGD steers from the beginning towards increasingly sharp regions until some maximum is reached; at this peak the SGD step length is large compared to the curvature along the sharpest directions (see Fig. 1 for an illustration). Moreover, SGD visits flatter regions for a larger learning rate or a smaller batch-size. ",
+        "bbox": [
+            174,
+            760,
+            823,
+            844
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 Largest eigenvalues of the Hessian along the SGD path ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            867,
+            691,
+            882
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We first investigate the training loss curvature in the sharpest directions, along the training trajectory for both the SimpleCNN and Resnet-32 models. ",
+        "bbox": [
+            174,
+            895,
+            818,
+            922
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Largest eigenvalues of the Hessian grow initially. In the first experiment we train SimpleCNN and Resnet-32 using SGD with $\\eta = 0 . 1$ and $S = 1 2 8$ and estimate the 10 largest eigenvalues of the Hessian, throughout training. As shown in Fig. 2 (top) the spectral norm (which corresponds to the largest eigenvalue), as well as the other tracked eigenvalues, grows in the first epochs up to a maximum value. After reaching this maximum value, we observe a relatively steady decrease of the largest eigenvalues in the following epochs. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To investigate the evolution of the curvature in the first epochs more closely, we track the eigenvalues at each iteration during the beginning of training, see Fig. 2 (bottom). We observe that initially the magnitudes of the largest eigenvalues grow rapidly. After this initial growth, the eigenvalues alternate between decreasing and increasing; this behaviour is also reflected in the evolution of the accuracy. This suggests SGD is initially driven to regions that are difficult to optimize due to large curvature. ",
+        "bbox": [
+            174,
+            194,
+            823,
+            277
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To study this further we look at a full-batch gradient descent training of Resnet- $3 2 ^ { 3 }$ . This experiment is also motivated by the instability of large-batch size training reported in the literature, as for example by Goyal et al. (2017). In the case of Resnet-32 (without Batch-Normalization) we can clearly see that the magnitude of the largest eigenvalues of the Hessian grows initially, which is followed by a sharp drop in accuracy suggesting instability of the optimization, see Fig. 3. We also observed that the instability is partially solved through use of Batch-Normalization layers, consistent with the findings of Bjorck et al. (2018), see Fig. 9 in Appendix. Finally, we report some additional results on the late phase of training, e.g. the impact of learning rate schedules, in Fig. 12 in the Appendix. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            410
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/242d3d5d962f495e4ce27838e2a86e82a44ada76f35b05119ca7830db38c638f.jpg",
+        "image_caption": [
+            "Figure 3: Full batch-size training of Resnet-32 for $\\eta = 0 . 0 1$ and (left) $\\eta = 0 . 0 5$ (right) on CIFAR-10. Evolution of the top 10 eigenvalues of the Hessian and accuracy are shown in each case. The training is unstable; an initial growth of curvature scale is followed by a sudden drop in accuracy. The CIFAR-10 dataset was subsampled to 2500 points. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            426,
+            797,
+            523
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Learning rate and batch-size limit the maximum spectral norm. Next, we investigate how the choice of learning rate and batch size impacts the SGD path in terms of its curvatures. Fig. 4 shows the evolution of the two largest eigenvalues of the Hessian during training of the SimpleCNN and Resnet-32 on CIFAR-10, and an LSTM on PTB, for different values of $\\eta$ and $S$ . We observe in this figure that a larger learning rate or a smaller batch-size correlates with a smaller and earlier peak of the spectral norm and the subsequent largest eigenvalue. Note that the phase in which curvature grows for low learning rates or large batch sizes can take many epochs. Additionally, momentum has an analogous effect – using a larger momentum leads to a smaller peak of spectral norm, see Fig. 13 in Appendix. Similar observations hold for VGG-11 and Resnet-32 using Batch-Normalization, see Appendix A.1. ",
+        "bbox": [
+            174,
+            633,
+            825,
+            773
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Summary. These results show that the learning rate and batch size not only influence the SGD endpoint maximum curvature, but also impact the whole SGD trajectory. A high learning rate or a small batch size limits the maximum spectral norm along the path found by SGD from the beginning of training. While this behavior was observed in all settings examined (see also the Appendix), future work could focus on a theoretical analysis, helping to establish the generality of these results. ",
+        "bbox": [
+            174,
+            794,
+            825,
+            877
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/522d5bd2a78acc0b4bda368465fd46ce4f846e40a6670ead8c64dd17cb10da22.jpg",
+        "image_caption": [
+            "Figure 4: Evolution of the two largest eigenvalues (solid and dashed line) of the Hessian for Resnet-32, SimpleCNN, and LSTM (trained on the PTB dataset) models on a log-scale for different learning rates (top) and batch-sizes (bottom). Blue/green/red correspond to increasing $\\eta$ and decreasing $S$ in each figure. Left side of the vertical blue bar in each plot corresponds to the early phase of training. Larger learning rate or a smaller batch-size correlates with a smaller and earlier peak of the spectral norm and the next largest eigenvalue. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            256,
+            98,
+            741,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 Sharpest direction and SGD step ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            429,
+            496,
+            444
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The training dynamics (which later we will see affect the speed and generalization capability of learning) are significantly affected by the evolution of the largest eigenvalues discussed in Section 3.1. To demonstrate this we study the relationship between the SGD step and the loss surface shape in the sharpest directions. As we will show, SGD dynamics are largely coupled with the shape of the loss surface in the sharpest direction, in the sense that when projected onto the sharpest direction, the typical step taken by SGD is too large compared to curvature to enable it to reduce loss. We study the same SimpleCNN and Resnet-32 models as in the previous experiment in the first 6 epochs of training with SGD with $\\eta { = } 0 . 0 1$ and $S = 1 2 8$ . ",
+        "bbox": [
+            174,
+            455,
+            825,
+            580
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The sharpest direction and the SGD step. First, we investigate the relation between the SGD step and the sharpest direction by looking at how the loss value changes on average when moving from the current parameters taking a step only along the sharpest direction - see Fig. 6 left. For all training iterations, we compute $\\mathbb { E } [ L ( \\pmb { \\theta } ( t ) - \\alpha \\eta \\tilde { \\pmb { g } } _ { 1 } ( t ) ) ] - L ( \\pmb { \\theta } ( t ) )$ , for $\\alpha \\in \\{ 0 . 2 5 , 0 . 5 , 1 , 2 , 4 \\}$ ; the expectation is approximated by an average over 10 different mini-batch gradients. We find that $\\mathbb { E } [ L ( \\pmb { \\theta } ( t ) - \\alpha \\eta \\tilde { \\pmb { g } } _ { 1 } ( t ) ) ]$ increases relative to $L ( \\pmb \\theta ( t ) )$ for $\\alpha > 1$ , and decreases for $\\alpha < 1$ . More specifically, for SimpleCNN we find that $\\alpha = 2$ and $\\alpha = 4$ lead to a $2 . 1 \\%$ and $1 1 . 1 \\%$ increase in loss, while $\\alpha = 0 . 2 5$ and $\\alpha = 0 . 5$ both lead to a decrease of approximately $2 \\%$ . For Resnet-32 we observe a $3 \\%$ and $1 3 . 1 \\%$ increase for $\\alpha = 2$ and $\\alpha = 4$ , and approximately a $0 . 5 \\%$ decrease for $\\alpha = 0 . 2 5$ and $\\alpha = 0 . 5$ , respectively. The observation that SGD step does not minimize the loss along the sharpest direction suggests that optimization is ineffective along this direction. This is also consistent with the observation that learning rate and batch-size limit the maximum spectral norm of the Hessian (as both impact the SGD step length). ",
+        "bbox": [
+            173,
+            595,
+            825,
+            790
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "These dynamics are important for the overall training due to a high alignment of SGD step with the sharpest directions. We compute the average cosine between the mini-batch gradient ${ \\mathbf { g } } ^ { S } ( t )$ and the top 5 sharpest directions $\\mathbf { e } _ { 1 } ( t ) , \\ldots . \\mathbf { e } _ { 5 } ( t )$ . We find the gradient to be highly aligned with the sharpest direction, that is, depending on $\\eta$ and model the maximum average cosine is roughly between 0.2 and 0.4. Full results are presented in Fig. 5. ",
+        "bbox": [
+            174,
+            796,
+            823,
+            867
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Qualitatively, SGD step crosses the minimum along the sharpest direction. Next, we qualitatively visualize the loss surface along the sharpest direction in the first few epochs of training, see Fig 6 (right). To better reflect the relation between the sharpest direction and the SGD step we scaled the visualization using the expected norm of the SGD step $\\Delta \\pmb { \\theta } _ { 1 } ( t ) = \\eta \\mathbb { E } ( | \\widetilde { g } _ { 1 } ( t ) | )$ where the expectation is over 10 mini-batch gradients. Specifically, we evaluate $L ( \\pmb \\theta ( t ) + k e _ { 1 } \\overline { { \\Delta \\pmb \\theta } } _ { 1 } ( t ) )$ , where $\\pmb \\theta ( t )$ is the current parameter vector, and $k$ is an interpolation parameter (we use $k \\in [ - 5 , 5 ] ,$ ). For both SimpleCNN and Resnet-32 models, we observe that the loss on the scale of $\\Delta \\theta _ { 1 } ( t )$ starts to show a bowl-like structure in the largest eigenvalue direction after six epochs. This further corroborates the previous result that SGD step length is large compared to curvature in the sharpest direction. ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a00a1829c07bd232120c208e1c3c0f73ed7e71c3c5eb4210bcac1b26464d712b.jpg",
+        "image_caption": [
+            "Figure 5: Average cosine between mini-batch gradient (y axis) and top sharpest directions (averaged over top 5) for different $\\eta$ (color) evaluated at different level of accuracies, during training (x axis). For comparison, the horizontal purple line is alignment with a random vector in the parameter space. Curves were smoothed for clarity. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            336,
+            98,
+            661,
+            185
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/62e1fe2175d1f73b4673903493cd60a2c3070f05afc02b20b007671efe558324.jpg",
+        "image_caption": [
+            "Figure 6: Early on in training, SGD finds a region such that in the sharpest direction, the SGD step length is often too large compared to curvature. Experiments on SimpleCNN and Resnet32, trained with $\\eta = 0 . 0 1$ , $S = 1 2 8$ , learning curves are provided in the Appendix. Left two: Average change in loss $\\mathbb { E } [ L ( \\pmb { \\theta } ( t ) - \\alpha \\eta \\tilde { \\pmb { g } } _ { 1 } ( t ) ) ] - L ( \\pmb { \\theta } ( t ) )$ , for $\\alpha = 0 . 5 , 1 , 2$ corresponding to red, green, and blue, respectively. On average, the SGD step length in the direction of the sharpest direction does not minimize the loss. The red points further show that increasing the step size by a factor of two leads to increasing loss (on average). Right two: Qualitative visualization of the surface along the top eigenvectors for SimpleCNN and Resnet-32 support that SGD step length is large compared to the curvature along the top eigenvector. At iteration $t$ we plot the loss $L ( \\pmb \\theta ( t ) + k e _ { 1 } \\overline { { \\Delta \\pmb \\theta } } _ { 1 } ( t ) )$ , around the current parameters $\\pmb \\theta ( t )$ , where $\\Delta \\theta _ { 1 } ( t )$ is the expected norm of the SGD step along the top eigenvector $e _ { 1 }$ . The $x$ -axis represents the interpolation parameter $k$ , the -axis the epoch, and the -axis the loss value, $y$ $z$ the color indicated spectral norm in the given epoch (increasing from blue to red). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            280,
+            810,
+            390
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            614,
+            825,
+            717
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Training and validation accuracy are reported in Appendix B. Furthermore, in the Appendix B we demonstrate that a similar phenomena happens along the lower eigenvectors, for different $\\eta$ , and in the later phase of training. ",
+        "bbox": [
+            174,
+            723,
+            825,
+            766
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Summary. We infer that SGD steers toward a region in which the SGD step is highly aligned with the sharpest directions and would on average increase the loss along the sharpest directions, if restricted to them. This in particular suggests that optimization is ineffective along the sharpest direction, which we will further study in Sec. 4. ",
+        "bbox": [
+            176,
+            787,
+            825,
+            843
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 How SGD steers to sharp regions in the beginning ",
+        "text_level": 1,
+        "bbox": [
+            181,
+            867,
+            638,
+            881
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Here we discuss the dynamics around the initial growth of the spectral norm of the Hessian.   \nWe will look at some variants of SGD which change how the sharpest directions get optimized. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/70ac01a2066a9bcb9e550a63718de21aa48fb4b22ba5437e73f16523593bb2d3.jpg",
+        "image_caption": [
+            "Figure 7: Evolution of the loss and the top eigenvalue during training with variations of SGD with parameter updates restricted to certain subspaces. All variants are initialized at the last iteration in Fig. 1. An SGD variant (orange) that follows at each iteration only the projection of the gradient on the top eigenvector of $\\mathbf { H }$ effectively finds a region with lower $\\lambda _ { m a x }$ but increases the loss, while a variant subtracting this projection from the gradient (red), finds a sharper region while achieving a similar loss level as vanilla SGD (blue). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            303,
+            99,
+            692,
+            196
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/f478981dcd8b38da2f166d2acebf1f2fc665f74badb7e55aa91d99acd2184e1c.jpg",
+        "image_caption": [
+            "Figure 8: Nudged-SGD for an increasing number of affected sharpest directions ( $K$ ) optimizes significantly faster, whilst generally finding increasingly sharp regions. Experiment is run using Resnet-32 and the Cifar-10 dataset. Left and center: Validation accuracy and the $\\lambda _ { m a x }$ and Frobenius norm (y axis, solid and dashed) using increasing $K$ (blue to red) compared against SGD baseline using the same $\\eta$ (black), during training (x axis). Rightmost: Test accuracy (red) and Frobenius norm (blue) achieved using NSGD with an increasing $K$ (x axis) compared to an SGD baseline using the same $\\eta$ (blue and red horizontal lines). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            304,
+            816,
+            401
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Experiment. We used the same SimpleCNN model initialized with the parameters reached by SGD in the previous experiment at the end of epoch 4. The parameter updates used by the three SGD variants, which are compared to vanilla SGD (blue), are based on the mini-batch gradient $\\pmb { g } ^ { ( S ) }$ as follows: variant 1 (SGD top, orange) only updates the parameters based on the projection of the gradient on the top eigenvector direction, i.e. $\\pmb { g } ( t ) = \\langle \\pmb { g } ^ { ( S ) } ( t ) , \\mathbf { e } _ { 1 } ( t ) \\rangle \\mathbf { e } _ { 1 } ( t )$ ; variant 2 (SGD constant top, green) performs updates along the constant direction of the top eigenvector ${ \\bf e } _ { 1 } ( 0 )$ of the Hessian in the first iteration, i.e. $\\pmb { g } ( t ) = \\langle \\pmb { g } ^ { ( S ) } ( t ) , \\mathbf { e } _ { 1 } ( 0 ) \\rangle \\mathbf { e } _ { 1 } ( 0 )$ ; variant 3 (SGD no top, red) removes the gradient information in the direction of the top eigenvector, i.e. $\\pmb { g } ( t ) = \\pmb { g } ^ { ( S ) } ( t ) - \\langle \\pmb { g } ^ { ( S ) } ( t ) , \\mathbf { e } _ { 1 } ( t ) \\rangle \\mathbf { e } _ { 1 } ( t )$ . We show results in the left two plots of Fig. 7. We observe that if we only follow the top eigenvector, we get to wider regions but don’t reach lower loss values, and conversely, if we ignore the top eigenvector we reach lower loss values but sharper regions. ",
+        "bbox": [
+            173,
+            535,
+            825,
+            709
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Summary. The take-home message is that SGD updates in the top eigenvector direction strongly influence the overall path taken in the early phase of training. Based on these results, we will study a related variant of SGD throughout the training in the next section. ",
+        "bbox": [
+            173,
+            724,
+            825,
+            767
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Optimizing faster while finding a good sharp region ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            787,
+            736,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this final section we study how the convergence speed of SGD and the generalization of the resulting model depend on the dynamics along the sharpest directions. ",
+        "bbox": [
+            173,
+            818,
+            823,
+            847
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Our starting point are the results presented in Sec. 3 which show that while the SGD step can be highly aligned with the sharpest directions, on average it fails to minimize the loss if restricted to these directions. This suggests that reducing the alignment of the SGD update direction with the sharpest directions might be beneficial, which we investigate here via a variant of SGD, which we call Nudged-SGD (NSGD). Our aim here is not to build a practical optimizer, but instead to see if our insights from the previous section can be utilized in an optimizer. NSGD is implemented as follows: instead of using the standard SGD update, $\\Delta \\pmb { \\theta } ( t ) = - \\eta \\pmb { g } ^ { ( S ) } ( t )$ , NSGD uses a different learning rate, $\\eta ^ { \\prime } = \\gamma \\eta$ , along just the top $K$ eigenvectors, while following the normal SGD gradient along all the others directions4. In particular we will study NSGD with a low base learning rate $\\eta$ , which will allow us to capture any implicit regularization effects NSGD might have. We ran experiments with Resnet-32 and SimpleCNN on CIFAR-10. Note, that these are not state-of-the-art models, which we leave for future investigation. ",
+        "bbox": [
+            174,
+            853,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/79166f46fa1940a7da66f8d47bc2ddaefdda085941f872370a0fa7f802e49dc2.jpg",
+        "table_caption": [
+            "Table 1: Nudged-SGD optimizes faster and finds a sharper final endpoint with a slightly better generalization performance. Experiments on Resnet-32 model on the Cifar-10 dataset. Columns: the Frobenius norm of the Hessian at the best validation point and the final epoch; test accuracy; validation at epoch 50; cross-entropy loss in the final epoch; distance of the parameters from the initialization to the best validation epoch parameters. Experiments were performed with $\\eta = 0 . 0 1$ and $S = 1 2 8$ . In the last rows we report SGD using $\\eta \\in \\{ 0 . 0 0 5 , 0 . 1 \\}$ . "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>1,018/1,019</td><td>87.3%</td><td>69.3%</td><td>0.01324</td><td>21.08</td></tr><tr><td>γ = 0.1</td><td>931/929</td><td>87.2%</td><td>69.0%</td><td>0.00940</td><td>21.32</td></tr><tr><td>γ = 1.0</td><td>272/324</td><td>86.6%</td><td>63.0%</td><td>0.01719</td><td>22.90</td></tr><tr><td>γ = 5.0</td><td>111/83</td><td>85.5%</td><td>52.3%</td><td>1.17170</td><td>25.32</td></tr><tr><td>SGD(0.005)</td><td>678/946</td><td>86.0%</td><td>49.9%</td><td>0.06221</td><td>18.87</td></tr><tr><td>SGD(0.1)</td><td>24/25</td><td>88.0%</td><td>84.7%</td><td>0.00100</td><td>50.73</td></tr></table>",
+        "bbox": [
+            225,
+            195,
+            772,
+            316
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            342,
+            825,
+            454
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We investigated NSGD with a different number of sharpest eigenvectors $K$ , in the range between 1 and 20; and with the rescaling factor $\\gamma \\in \\{ 0 . 0 1 , 0 . 1 , 1 , 5 \\}$ . The top eigenvectors are recomputed at the beginning of each epoch5. We compare the sharpness of the reached endpoint by both computing the Frobenius norm (approximated by the top 50 eigenvectors), and the spectral norm of the Hessian. The learning rate is decayed by a factor of 10 when validation loss has not improved for 100 epochs. Experiments are averaged over two random seeds. When talking about the generalization we will refer to the test accuracy at the best validation accuracy epoch. Results for Resnet-32 are summarized in Fig. 8 and Tab. 1; for full results on SimpleCNN we relegate the reader to Appendix, Tab. 2. In the following we will highlight the two main conclusions we can draw from the experimental data. ",
+        "bbox": [
+            173,
+            460,
+            825,
+            599
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "NSGD optimizes faster, whilst traversing a sharper region. First, we observe that in the early phase of training NSGD optimizes significantly faster than the baseline, whilst traversing a region which is an order of magnitude sharper. We start by looking at the impact of $K$ which controls the amount of eigenvectors with adapted learning rate; we test $K$ in $\\{ 1 , \\ldots , 2 0 \\}$ with a fixed $\\gamma = 0 . 0 1$ . On the whole, increasing $K$ correlates with a significantly improved training speed and visiting much sharper regions (see Fig. 8). We highlight that NSGD with $K = 2 0$ reaches a maximum $\\lambda _ { m a x }$ of approximately $8 \\cdot 1 0 ^ { 3 }$ compared to baseline SGD reaching approximately 150. Further, NSGD retains an advantage of over 5% ( $1 \\%$ for SimpleCNN) validation accuracy, even after 50 epochs of training (see Tab. 1). ",
+        "bbox": [
+            173,
+            614,
+            825,
+            739
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "NSGD can improve the final generalization performance, while finding a sharper final region. Next, we turn our attention to the results on the final generalization and sharpness. We observe from Tab. 1 that using $\\gamma < 1$ can result in finding a significantly sharper endpoint exhibiting a slightly improved generalization performance compared to baseline SGD using the same $\\eta = 0 . 0 1$ . On the contrary, using $\\gamma > 1$ led to a wider endpoint and a worse generalization, perhaps due to the added instability. Finally, using a larger $K$ generally correlates with an improved generalization performance (see Fig. 8, right). ",
+        "bbox": [
+            173,
+            755,
+            825,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            821,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "More specifically, baseline SGD using the same learning rate reached $8 6 . 4 \\%$ test accuracy with the Frobenius norm of the Hessian $| | \\mathbf { H } | | _ { F } = 2 7 2$ ( $8 6 . 6 \\%$ with $| | \\mathbf { H } | | _ { F } = 1 9 1$ on SimpleCNN). In comparison, NSGD using $\\gamma = 0 . 0 1$ found endpoint corresponding to $8 7 . 0 \\%$ test accuracy and $| | \\mathbf { H } | | _ { F } = 1 0 1 8$ (87.4% and $| | \\mathbf { H } | | _ { F } = 2 8 7$ on SimpleCNN). Finally, note that in the case of Resnet-32 $K = 2 0$ leads to $8 8 \\%$ test accuracy and $| | \\mathbf { H } | | _ { F } = 1 1 0 0$ which closes the generalization gap to SGD using $\\eta = 0 . 1$ . We note that runs corresponding to $\\eta = 0 . 0 1$ generally converge at final cross-entropy loss around 0.01 and over $9 9 \\%$ training accuracy. ",
+        "bbox": [
+            174,
+            138,
+            825,
+            236
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "As discussed in Sagun et al. (2017) the structure of the Hessian can be highly dataset dependent, thus the demonstrated behavior of NSGD could be dataset dependent as well. In particular NSGD impact on the final generalization can be dataset dependent. In the Appendix C and Appendix F we include results on the CIFAR-100, Fashion MNIST (Xiao et al., 2017) and IMDB (Maas et al., 2011) datasets, but studies on more diverse datasets are left for future work. In these cases we observed a similar behavior regarding faster optimization and steering towards sharper region, while generalization of the final region was not always improved. Finally, we relegate to the Appendix C additional studies using a high base learning and momentum. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            368
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Summary. We have investigated what happens if SGD uses a reduced learning rate along the sharpest directions. We show that this variant of SGD, i.e. NSGD, steers towards sharper regions in the beginning. Furthermore, NSGD is capable of optimizing faster and finding good generalizing sharp minima, i.e. regions of the loss surface at the convergence which are sharper compared to those found by vanilla SGD using the same low learning rate, while exhibiting better generalization performance. Note that in contrast to Dinh et al. (2017) the sharp regions that we investigate here are the endpoints of an optimization procedure, rather than a result of a mathematical reparametrization. ",
+        "bbox": [
+            174,
+            388,
+            825,
+            501
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5 Related work ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            348,
+            542
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tracking the Hessian: The largest eigenvalues of the Hessian of the loss of DNNs were investigated previously but mostly in the late phase of training. Some notable exceptions are: LeCun et al. (1998) who first track the Hessian spectral norm, and the initial growth is reported (though not commented on). Sagun et al. (2016) report that the spectral norm of the Hessian reduces towards the end of training. Keskar et al. (2016) observe that a sharpness metric grows initially for large batch-size, but only decays for small batch-size. Our observations concern the eigenvalues and eigenvectors of the Hessian, which follow the consistent pattern, as discussed in Sec. 3.1. Finally, Yao et al. (2018) study the relation between the Hessian and adversarial robustness at the endpoint of training. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            686
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Wider minima generalize better: Hochreiter and Schmidhuber (1997) argued that wide minima should generalize well. Keskar et al. (2016) provided empirical evidence that the width of the endpoint minima found by SGD relates to generalization and the used batch-size. Jastrzębski et al. (2017) extended this by finding a correlation of the width and the learning rate to batch-size ratio. Dinh et al. (2017) demonstrated the existence of reparametrizations of networks which keep the loss value and generalization performance constant while increasing sharpness of the associated minimum, implying it is not just the width of a minimum which determines the generalization. Recent work further explored importance of curvature for generalization (Wen et al., 2018; Wang et al., 2018). ",
+        "bbox": [
+            174,
+            694,
+            823,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Stochastic gradient descent dynamics. Our work is related to studies on SGD dynamics such as Goodfellow et al. (2014); Chaudhari and Soatto (2017); Xing et al. (2018); Zhu et al. (2018). In particular, recently Zhu et al. (2018) investigated the importance of noise along the top eigenvector for escaping sharp minima by comparing at the final minima SGD with other optimizer variants. In contrast we show that from the beginning of training SGD visits regions in which SGD step is too large compared to curvature. Concurrent with this work Xing et al. (2018) by interpolating the loss between parameter values at consecutive iterations show it is roughly-convex, whereas we show a related phenomena by investigating the loss in the subspace of the sharpest directions of the Hessian. ",
+        "bbox": [
+            174,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 Conclusions ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            152,
+            328,
+            169
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The somewhat puzzling empirical correlation between the endpoint curvature and its generalization properties reached in the training of DNNs motivated our study. Our main contribution is exposing the relation between SGD dynamics and the sharpest directions, and investigating its importance for training. SGD steers from the beginning towards increasingly sharp regions of the loss surface, up to a level dependent on the learning rate and the batch-size. Furthermore, the SGD step is large compared to the curvature along the sharpest directions, and highly aligned with them. ",
+        "bbox": [
+            174,
+            184,
+            825,
+            281
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Our experiments suggest that understanding the behavior of optimization along the sharpest directions is a promising avenue for studying generalization properties of neural networks. Additionally, results such as those showing the impact of the SGD step length on the regions visited (as characterized by their curvature) may help design novel optimizers tailor-fit to neural networks. ",
+        "bbox": [
+            174,
+            289,
+            825,
+            358
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Acknowledgements ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            381,
+            370,
+            395
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "SJ was supported by grant No. DI 2014/016644 from Ministry of Science and Higher Education, Poland. SJ also received funding from projects No. 2017/25/B/ST6/01271 and No. 2017/24/T/ST6/00487 from National Science Center, Poland. Work at Mila was funded by NSERC, CIFAR, and Canada Research Chairs. This project has received funding from the European Union’s Horizon 2020 research and innovation programme under grant agreement No 732204 (Bonseyes). This work is supported by the Swiss State Secretariat for Education‚ Research and Innovation (SERI) under contract number 16.0159. ",
+        "bbox": [
+            174,
+            411,
+            825,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            530,
+            290,
+            545
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Madhu S Advani and Andrew M Saxe. High-dimensional dynamics of generalization error in neural networks. arXiv preprint arXiv:1710.03667, 2017. ",
+        "bbox": [
+            173,
+            553,
+            823,
+            582
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J. Bjorck, C. Gomes, and B. Selman. Understanding Batch Normalization. ArXiv e-prints, May 2018. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            621
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "P. Chaudhari and S. Soatto. Stochastic gradient descent performs variational inference, converges to limit cycles for deep networks. ArXiv e-prints, October 2017. ",
+        "bbox": [
+            176,
+            631,
+            823,
+            660
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "François Chollet et al. Keras. https://github.com/keras-team/keras, 2015. ",
+        "bbox": [
+            176,
+            671,
+            740,
+            685
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yann Dauphin, Razvan Pascanu, Çaglar Gülçehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. CoRR, abs/1406.2572, 2014. URL http://arxiv.org/abs/ 1406.2572. ",
+        "bbox": [
+            174,
+            696,
+            825,
+            752
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Laurent Dinh, Razvan Pascanu, Samy Bengio, and Yoshua Bengio. Sharp minima can generalize for deep nets. arXiv preprint arXiv:1703.04933, 2017. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "I. J. Goodfellow, O. Vinyals, and A. M. Saxe. Qualitatively characterizing neural network optimization problems. ArXiv e-prints, December 2014. ",
+        "bbox": [
+            169,
+            803,
+            823,
+            832
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollár, Ross B. Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, Andrew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch SGD: training imagenet in 1 hour. CoRR, abs/1706.02677, 2017. ",
+        "bbox": [
+            176,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sepp Hochreiter and Jürgen Schmidhuber. Flat minima. Neural Computation, 9(1):1–42, 1997. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Stanisław Jastrzębski, Zachary Kenton, Devansh Arpit, Nicolas Ballas, Asja Fischer, Yoshua Bengio, and Amos Storkey. Three factors influencing minima in sgd. arXiv preprint arXiv:1711.04623, 2017. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "N.S.= Keskar, D. Mudigere, J. Nocedal, M. Smelyanskiy, and P. T. P. Tang. On Large-Batch Training for Deep Learning: Generalization Gap and Sharp Minima. ArXiv e-prints, September 2016. ",
+        "bbox": [
+            176,
+            155,
+            823,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Vinod Nair, and Geoffrey Hinton. Cifar-10 (canadian institute for advanced research). URL http://www.cs.toronto.edu/\\~kriz/cifar.html. ",
+        "bbox": [
+            176,
+            207,
+            820,
+            237
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Cornelius Lanczos. An iteration method for the solution of the eigenvalue problem of linear differential and integral operators. J. Res. Natl. Bur. Stand. B, 45:255–282, 1950. doi: 10.6028/jres.045.026. ",
+        "bbox": [
+            173,
+            244,
+            826,
+            287
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Léon Bottou, Genevieve B. Orr, and Klaus-Robert Müller. Efficient backprop. In Neural Networks: Tricks of the Trade, This Book is an Outgrowth of a 1996 NIPS Workshop, pages 9–50, London, UK, UK, 1998. Springer-Verlag. ISBN 3-540-65311-2. URL http://dl.acm.org/citation.cfm?id=645754.668382. ",
+        "bbox": [
+            174,
+            297,
+            825,
+            354
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Andrew L. Maas, Raymond E. Daly, Peter T. Pham, Dan Huang, Andrew Y. Ng, and Christopher Potts. Learning word vectors for sentiment analysis. In Proceedings of the 49th Annual Meeting of the Association for Computational Linguistics: Human Language Technologies - Volume 1, HLT ’11, pages 142–150, Stroudsburg, PA, USA, 2011. Association for Computational Linguistics. ISBN 978-1-932432-87-9. URL http://dl.acm.org/ citation.cfm?id=2002472.2002491. ",
+        "bbox": [
+            173,
+            363,
+            826,
+            448
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Noboru Murata, Shuji Yoshizawa, and Shun ichi Amari. Network information criteriondetermining the number of hidden units for an artificial neural network model. IEEE transactions on neural networks, 5 6:865–72, 1994. ",
+        "bbox": [
+            174,
+            457,
+            826,
+            501
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Behnam Neyshabur, Srinadh Bhojanapalli, David McAllester, and Nathan Srebro. Exploring generalization in deep learning. CoRR, abs/1706.08947, 2017. URL http://arxiv.org/ abs/1706.08947. ",
+        "bbox": [
+            174,
+            508,
+            826,
+            551
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Tomaso Poggio, Kenji Kawaguchi, Qianli Liao, Brando Miranda, Lorenzo Rosasco, Xavier Boix, Jack Hidary, and Hrushikesh Mhaskar. Theory of deep learning iii: explaining the non-overfitting puzzle. arXiv preprint arXiv:1801.00173, 2017. ",
+        "bbox": [
+            174,
+            561,
+            826,
+            604
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Levent Sagun, Léon Bottou, and Yann LeCun. Singularity of the hessian in deep learning. arXiv preprint arXiv:1611.07476, 2016. ",
+        "bbox": [
+            171,
+            613,
+            825,
+            643
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Levent Sagun, Utku Evci, V Ugur Guney, Yann Dauphin, and Leon Bottou. Empirical analysis of the hessian of over-parametrized neural networks. arXiv preprint arXiv:1706.04454, 2017. ",
+        "bbox": [
+            174,
+            651,
+            823,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. CoRR, abs/1409.1556, 2014. URL http://arxiv.org/abs/1409.1556. ",
+        "bbox": [
+            171,
+            704,
+            825,
+            733
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Masato Taki. Deep residual networks and weight initialization. CoRR, abs/1709.02956, 2017. URL http://arxiv.org/abs/1709.02956. ",
+        "bbox": [
+            173,
+            742,
+            825,
+            771
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Wang, N. Keskar, C. Xiong, and R. Socher. Identifying Generalization Properties in Neural Networks. ArXiv e-prints, September 2018. ",
+        "bbox": [
+            173,
+            780,
+            823,
+            810
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "W. Wen, Y. Wang, F. Yan, C. Xu, C. Wu, Y. Chen, and H. Li. SmoothOut: Smoothing Out Sharp Minima to Improve Generalization in Deep Learning. ArXiv e-prints, May 2018. ",
+        "bbox": [
+            174,
+            818,
+            823,
+            848
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Ashia C Wilson, Rebecca Roelofs, Mitchell Stern, Nathan Srebro, and Benjamin Recht. The marginal value of adaptive gradient methods in machine learning. 2017. ",
+        "bbox": [
+            174,
+            856,
+            820,
+            886
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "H. Xiao, K. Rasul, and R. Vollgraf. Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms. ArXiv e-prints, August 2017. ",
+        "bbox": [
+            176,
+            895,
+            820,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C. Xing, D. Arpit, C. Tsirigotis, and Y. Bengio. A Walk with SGD. ArXiv e-prints, February 2018.   \nZhewei Yao, Amir Gholami, Qi Lei, Kurt Keutzer, and Michael W Mahoney. Hessianbased analysis of large batch training and robustness to adversaries. arXiv preprint arXiv:1802.08241, 2018.   \nWojciech Zaremba, Ilya Sutskever, and Oriol Vinyals. Recurrent neural network regularization, 2014. URL https://arxiv.org/abs/1409.2329.   \nChiyuan Zhang, Samy Bengio, Moritz Hardt, Benjamin Recht, and Oriol Vinyals. Understanding deep learning requires rethinking generalization. arXiv preprint arXiv:1611.03530, 2016.   \nZ. Zhu, J. Wu, B. Yu, L. Wu, and J. Ma. The Regularization Effects of Anisotropic Noise in Stochastic Gradient Descent. ArXiv e-prints, February 2018. ",
+        "bbox": [
+            173,
+            102,
+            828,
+            311
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A Additional results for Sec. 3.1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            524,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 Additional results on the evolution of the largest eigenvalues of the Hessian ",
+        "bbox": [
+            176,
+            136,
+            821,
+            164
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "First, we show that the instability in the early phase of full-batch training is partially solved through use of Batch-Normalization layers, consistent with the results reported by Bjorck et al. (2018); results are shown in Fig. 9. ",
+        "bbox": [
+            176,
+            176,
+            823,
+            219
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/41723527114f7efa78bbfa9b0948ab636b724ce663a7613689f989b84f83b0b2.jpg",
+        "image_caption": [
+            "Figure 9: Full-batch training with Batch-Normalization is more stable. Evolution of the top 10 eigenvalues of the Hessian, and accuracy, for Resnet-32 trained on the CIFAR-10 dataset with $\\eta = 0 . 0 1$ (left) and $\\eta = 0 . 0 5$ (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            236,
+            802,
+            332
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Next, we extend results of Sec. 3.1 to VGG-11 and Batch-Normalized Resnet-32 models, see Fig. 11 and Fig. 10. Importantly, we evaluated the Hessian in the inference mode, which resulted in large absolute magnitudes of the eigenvalues on Resnet-32. ",
+        "bbox": [
+            173,
+            415,
+            823,
+            457
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/7c664de8ff7a8992af176f3c0852acb792ab6c9f8c71d648a63d3b28cd0b5330.jpg",
+        "image_caption": [
+            "Figure 10: Same as Fig. 4, but for the VGG-11 architecture. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            334,
+            473,
+            660,
+            564
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/bdcf296817cad447992f1f09319e31002f7c321a54fc38ec098fd2d9d72e76db.jpg",
+        "image_caption": [
+            "Figure 11: Same as Fig. 4, but for Resnet-32 architecture using Batch-Normalization layers. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            323,
+            625,
+            676,
+            717
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.2 Impact of learning rate schedule ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            771,
+            504,
+            785
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In the paper we focused mostly on SGD using a constant learning rate and batch-size. We report here the evolution of the spectral and Frobenius norm of the Hessian when using a simple learning rate schedule in which we vary the length of the first stage $L$ ; we use $\\eta = 0 . 1$ for $L$ epochs and drop it afterwards to $\\eta = 0 . 0 1$ . We test $L$ in $\\{ 1 0 , 2 0 , 4 0 , 8 0 \\}$ . Results are reported in Fig. 12. The main conclusion is that depending on the learning rate schedule in the next stages of training curvature along the sharpest directions (measured either by the spectral norm, or by the Frobenius norm) can either decay or grow. Training for a shorter time (a lower $L$ ) led to a growth of curvature (in term of Frobenius norm and spectral norm) after the learning drop, and a lower final validation accuracy. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/d3114aefe1309905907df798eac56eb7b3d8aef35352f28ba5d1056f6d4838e7.jpg",
+        "image_caption": [
+            "Figure 12: Depending on the length of the first stage of a learning rate schedule, spectral norm of the Hessian and generalization performance evolve differently. Left: Spectral norm of the Hessian (solid) and Frobenius norm (dashed), during training (x axis). Center: Accuracy and validation accuracy, during training (x axis). Right: Learning rate, during training (x axis). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            223,
+            98,
+            774,
+            193
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "A.3 Impact of using momentum ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            314,
+            441,
+            327
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In the paper we focused mostly on experiments using plain SGD, without momentum. In this section we report that large momentum similarly to large $\\eta$ leads to a reduction of spectral norm of the Hessian, see Fig. 13 for results on the VGG11 network on CIFAR10 and CIFAR100. ",
+        "bbox": [
+            174,
+            344,
+            826,
+            401
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/df2ac8aa0d130438e18fac56a3c3f21b8d2f4f62e184b03e9070076154404c31.jpg",
+        "image_caption": [
+            "Figure 13: Momentum limits the maximum spectral norm of the Hessian throughout training. Training at $\\eta = 0 . 1$ and $S = 1 2 8$ on VGG11 and CIFAR10 (left) and CIFAR100 (right). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            285,
+            425,
+            712,
+            536
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B Additional results for Sec. 3.2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            616,
+            526,
+            632
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "In Fig. 14 we report the corresponding training and validation curves for the experiments depicted in Fig. 6. Next, we plot an analogous visualization as in Fig. 6, but for the 3rd and 5th eigenvector, see Fig. 15 and Fig. 16, respectively. To ensure that the results do not depend on the learning rate, we rerun the Resnet-32 and SimpleCNN experiments with $\\eta = 0 . 0 5$ , see Fig. 17. ",
+        "bbox": [
+            173,
+            656,
+            825,
+            727
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Finally, we run the same experiment as in Sec. 3.2, but instead of focusing on the early phase we replot Fig. 6 for the first 200 epochs, see Fig. 18 ",
+        "bbox": [
+            173,
+            733,
+            821,
+            762
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/ea2f09838b66615f4b3cff0618574553bea35687e3dc19d056303b31107b79ab.jpg",
+        "image_caption": [
+            "Figure 14: Training and validation accuracy for experiments in Fig 6. Left corresponds to SimpleCNN. Right corresponds to Resnet-32. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            326,
+            787,
+            669,
+            881
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/9e7aecda0593871d15f2a9425bc8b7f478a5ed29ece05517fb59df0d6b89ff65.jpg",
+        "image_caption": [
+            "Figure 15: Similar to Fig 6 but computed for the third eigenvector of the Hessian. We see that the loss surface is much flatter in this direction. To facilitate a direct comparison, scale of each axis is kept the same as in Fig. 6. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            109,
+            790,
+            210
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/6583f9f931606570e5c518e09b9442f98a11e8ae6cb5e95e3408647e0577f992.jpg",
+        "image_caption": [
+            "Figure 16: Similar to $\\mathrm { F i g ~ 6 ~ }$ but for the fourth eigenvector. We see that the loss surface is much flatter in this direction. To facilitate a direct comparison, scale of each axis is kept the same as in Fig. 6. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            300,
+            792,
+            402
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/715094b9e1836f3ac90e5d2dbd8e1068adef70f300da19fa51191549bb48d2c2.jpg",
+        "image_caption": [
+            "Figure 17: Similar to Fig 6 but for Resnet-32 (top) and SimpleCNN (bottom) with $\\eta = 0 . 0 5$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            205,
+            491,
+            792,
+            594
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/05b650e721742b7412c7ed476ab15c20502a68b550245cd35ce553a27c0cb5b5.jpg",
+        "image_caption": [
+            "Figure 18: Similar to Fig 6 but for Resnet-32 (top) and SimpleCNN (bottom) run for 200 epochs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            202,
+            655,
+            794,
+            758
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "C Additional results for Sec. 4 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            823,
+            509,
+            838
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Here we report additional results for Sec. 4. Most importantly, in Tab. 2 we report full results for SimpleCNN model. Next, we rerun the same experiment, using the Resnet-32 model, on the CIFAR-100 dataset, see Tab. 5, and on the Fashion-MNIST dataset, see Tab. 6. In the case of CIFAR-100 we observe that conclusion carry-over fully. In the case of Fashion-MNIST we observe that the final generalization for the case of $\\gamma < 1$ and $\\gamma = 1 . 0$ is similar. Therefore, as discussed in the main text, the behavior seems to be indeed dataset dependent. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/fc870a05dc339849e38391eee5f2b373c2b2cec256690ed49ff22a22b1451f16.jpg",
+        "image_caption": [
+            "Figure 19: Evolution of the spectral norm and Frobenius norm of the Hessian (y axis, solid and dashed line, respectively) for different $\\gamma$ (color) for the experiment using a larger learning (left) and momentum (right), see text for details. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            267,
+            97,
+            732,
+            210
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            295,
+            821,
+            323
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "In Sec. 4 we purposedly explored NSGD in the context of suboptimally picked learning rate, which allowed us to test if NSGD has any implicit regularization effect. In the next two experiments we explored how NSGD performs when using either a large base learning $\\eta$ , or when using momentum. Results are reported in Tab. 3 (learning rate $\\eta = 0 . 1$ ) and Tab. 4 (momentum $\\mu = 0 . 9$ ). In both cases we observe that NSGD improves training speed and reaches a significantly sharper region initially, see Fig. 22. However, the final region curvature in both cases, and the final generalization when using momentum, is not significantly affected. Further study of NSGD using a high learning rate or momentum is left for future work. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            443
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/e082244965e8cf3f0f21f9d9bdef9016189ca66b2062eb5f048c65acf33fbebd.jpg",
+        "table_caption": [
+            "Table 2: Same as Tab. 1, but for Simple-CNN model. NSGD with $\\gamma = 5 . 0$ diverged and was excluded from the Table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>||H||F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>423/429</td><td>87.1%</td><td>83.5%</td><td>0.00143</td><td>17.63</td></tr><tr><td>γ=0.1</td><td>294/268</td><td>87.4%</td><td>83.3%</td><td>0.00126</td><td>17.98</td></tr><tr><td>γ = 1.0</td><td>127/127</td><td>86.6%</td><td>82.3%</td><td>0.00063</td><td>19.76</td></tr><tr><td>γ = 5.0</td><td>130/129</td><td>85.2%</td><td>79.8%</td><td>0.00160</td><td>20.26</td></tr><tr><td>SGD(0.005)</td><td>476/516</td><td>85.8%</td><td>78.0%</td><td>0.00862</td><td>14.94</td></tr><tr><td>SGD(0.05)</td><td>34/26</td><td>87.4%</td><td>85.1%</td><td>0.00008</td><td>35.38</td></tr></table>",
+        "bbox": [
+            254,
+            501,
+            741,
+            613
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/df11881e6148bb82a2d889995c237c1fc2cbad73568ff12ba37a77ca78532db6.jpg",
+        "table_caption": [
+            "Table 3: Same as Tab. 1, but for Resnet-32 and NSGD using base learning rate $\\eta = 0 . 1$ NSGD with $\\gamma = 5 . 0$ diverged and was excluded from the Table. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>|H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>32/34</td><td>89.3%</td><td>85.8%</td><td>0.00322</td><td>49.04</td></tr><tr><td>γ=0.1</td><td>20/26</td><td>89.2%</td><td>85.9%</td><td>0.00105</td><td>50.73</td></tr><tr><td>γ = 1.0</td><td>25/19</td><td>87.9%</td><td>83.2%</td><td>0.00246</td><td>50.70</td></tr></table>",
+        "bbox": [
+            272,
+            693,
+            725,
+            760
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/60873e5acac507d96b4902c6a2319afa2d4b689431d11459e364486d5e26951a.jpg",
+        "table_caption": [
+            "Table 4: Same as Tab. 1, but for Resnet-32 and NSGD using momentum coefficient 0.9. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>|H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>20/20</td><td>89.4%</td><td>86.9%</td><td>0.00225</td><td>47.57</td></tr><tr><td>γ=0.1</td><td>36/32</td><td>89.3%</td><td>87.1%</td><td>0.00082</td><td>47.14</td></tr><tr><td>γ = 1.0</td><td>27/34</td><td>89.2%</td><td>85.8%</td><td>0.00239</td><td>49.57</td></tr><tr><td>γ=5.0</td><td>35/44</td><td>88.2%</td><td>83.9%</td><td>0.00438</td><td>51.07</td></tr></table>",
+        "bbox": [
+            274,
+            833,
+            723,
+            912
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "table",
+        "img_path": "images/e8d9c86c60a645ca97b662e5ffeb3fa7ee45c90458ae2f1778c8d7b8aea7d494.jpg",
+        "table_caption": [
+            "Table 5: Same as Tab. 1, but for Simple-CNN and NSGD on the Fashion-MNIST dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>|H|F</td><td>Test acc.</td><td>Val. acc. （(50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>294/431</td><td>92.6%</td><td>90.3%</td><td>0.05300</td><td>13.73</td></tr><tr><td>γ = 0.1</td><td>257/341</td><td>92.4%</td><td>90.1%</td><td>0.04340</td><td>13.62</td></tr><tr><td>γ = 1.0</td><td>159/162</td><td>92.5%</td><td>89.8%</td><td>0.04672</td><td>14.85</td></tr><tr><td>γ= 5.0</td><td>75/101</td><td>91.7%</td><td>89.2%</td><td>0.07820</td><td>14.65</td></tr></table>",
+        "bbox": [
+            266,
+            127,
+            730,
+            207
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "table",
+        "img_path": "images/8841e241e8a86e3a30cdd804de1abee67a349882f930347a131702e12ad04342.jpg",
+        "table_caption": [
+            "Table 6: Same as Tab. 1, but for Resnet-32 and NSGD on the CIFAR-100 dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>||H|F</td><td>Test acc.</td><td>Val. acc. (50)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ = 0.01</td><td>1,315/1,544</td><td>56.9%</td><td>27.8%</td><td>0.18048</td><td>31.37</td></tr><tr><td>γ=0.1</td><td>797/1,192</td><td>57.4%</td><td>27.0%</td><td>0.29081</td><td>31.18</td></tr><tr><td>γ = 1.0</td><td>470/720</td><td>54.1%</td><td>25.6%</td><td>0.28299</td><td>32.67</td></tr><tr><td>γ= 5.0</td><td>240/378</td><td>53.2%</td><td>20.6%</td><td>0.51348</td><td>34.20</td></tr></table>",
+        "bbox": [
+            253,
+            285,
+            745,
+            364
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "D SimpleCNN Model ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            406,
+            393,
+            422
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The SimpleCNN used in this paper has four convolutional layers. The first two have 32 filters, while the third and fourth have 64 filters. In all convolutional layers, the convolutional kernel window size used is (3,3) and ‘same’ padding is used. Each convolutional layer is followed by a ReLU activation function. Max-pooling is used after the second and fourth convolutional layer, with a pool-size of (2,2). After the convolutional layers there are two linear layers with output size 128 and 10 respectively. After the first linear layer ReLU activation is used. After the final linear layer a softmax is applied. Please also see the provided code. ",
+        "bbox": [
+            173,
+            441,
+            826,
+            540
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "E Comparing NSGD to Newton Method ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            566,
+            584,
+            583
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "Nudged-SGD is a second order method, in the sense that it leverages the curvature of the loss surface. In this section we argue that it is significantly different from the Newton method, a representative second order method. ",
+        "bbox": [
+            176,
+            603,
+            821,
+            645
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "The key reason for that is that, similarly to SGD, NSGD is driven to a region in which curvature is too large compared to its typical step. In other words NSGD does not use an optimal learning rate for the curvature, which is the key design principle for second order methods. This is visible in Fig. 20, where we report results of a similar study as in Sec. 3.2, but for NSGD ( $K = 5$ , $\\gamma = 0 . 0 1$ ). The loss surface appears sharper in this plot, because reducing gradients along the top $K$ sharpest directions allows optimizing over significantly sharper regions. ",
+        "bbox": [
+            173,
+            651,
+            825,
+            750
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "As discussed, the key difference stems for the early bias of SGD to reach maximally sharp regions. It is therefore expected that in case of a quadratic loss surface Newton and NSGD optimizers are very similar. In the following we construct such an example. First, recall that update in Newton method is typically computed as: ",
+        "bbox": [
+            174,
+            756,
+            825,
+            813
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e427ac7b2f7c950b45ae6de9a6175a5ebb35cf2320254338f9a51d7a520edbc7.jpg",
+        "text": "$$\n\\pmb \\theta ( t + 1 ) = \\pmb \\theta ( t ) - \\eta ( H + \\lambda I ) ^ { - 1 } \\boldsymbol g ^ { S } ( \\pmb \\theta ( t ) ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            357,
+            842,
+            640,
+            859
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "text",
+        "text": "where $\\lambda$ is a scalar. Now, if we assume that $H$ is diagonal and put $d i a g ( H ) \\ =$ $[ 1 0 0 , 1 0 0 , 1 0 0 , 1 0 0 , 1 0 0 , 1 , 1 ]$ , and finally let $\\lambda = 0$ , it can be seen that the update of NSGD with $\\gamma = 0 . 0 1$ and $K = 5$ is equivalent to that of Newton method. ",
+        "bbox": [
+            174,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/7b4b332909e5c367a108fb7152e64ed8a46960d1edd628f8f6fa7c6ec5d4dda7.jpg",
+        "image_caption": [
+            "Figure 20: Same as Fig. 6, but for NSGD with $\\gamma = 0 . 0 1$ and $K = 5$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            109,
+            810,
+            218
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "F Experiments on sentiment analysis dataset ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            280,
+            643,
+            295
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Most of the experiments in the paper focused on image classification datasets (except for language modeling experiments in Sec. 3.1). The goal of this section is to extend some of the experiments to the text domain. We experiment with the IMDB (Maas et al., 2011) binary sentiment classification dataset and use the simple CNN model from the Keras (Chollet et al., 2015) example repository6. ",
+        "bbox": [
+            173,
+            314,
+            825,
+            386
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "First, we examine the impact of learning rate and batch-size on the Hessian along the training trajectory as in Sec. 3.1. We test $\\eta \\in \\{ 0 . 0 2 5 , 0 . 0 5 , 0 . 1 \\}$ and $S \\in \\{ 2 , 8 , 3 2 \\}$ . As in Sec. 3.1 we observe that the learning rate and the batch-size limit the maximum curvature along the training trajectory. In this experiment the phase in which the curvature grows took many epochs, in contrast to the CIFAR-10 experiments. The results are summarized in Fig. 21. ",
+        "bbox": [
+            173,
+            392,
+            825,
+            462
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "Next, we tested Nudged SGD with $\\eta = 0 . 0 1$ , $S = 8$ and $K = 1$ . We test $\\gamma \\in \\{ 0 . 1 , 1 . 0 , 5 . 0 \\}$ . We increased the number of parameters of the base model by increasing by a factor of 2 number of filters in the first convolutional layer and the number of neurons in the dense layer to encourage overfitting. Experiments were repeated over 3 seeds. ",
+        "bbox": [
+            173,
+            468,
+            825,
+            525
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "text",
+        "text": "We observe that in this setting NSGD for $\\gamma < 1$ optimizes significantly faster and finds a sharper region initially. At the same time using $\\gamma < 1$ does not result in finding a better generalizing region. The results are summarized in Tab. 7 and Fig. 22. ",
+        "bbox": [
+            173,
+            531,
+            825,
+            574
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/de17dffd2f01bb5f3f9761286028a745b45652f9b439321b6b2ac5d9768dc85c.jpg",
+        "image_caption": [
+            "Figure 21: Same as Fig. 4, but for CNN model on the IMDB dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            331,
+            593,
+            666,
+            685
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "image",
+        "img_path": "images/58c44cbcfd3c6722f3b8e492c6b6e903f2382e45623c1b9637519b5504a92c51.jpg",
+        "image_caption": [
+            "Figure 22: NSGD experiments on IMDB dataset. Evolution of the validation accuracy (left) and spectral norm of the Hessian (left) for different $\\gamma$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            325,
+            753,
+            673,
+            844
+        ],
+        "page_idx": 17
+    },
+    {
+        "type": "table",
+        "img_path": "images/b65fcdd002f9791bd4a9b8d1e448f6174087ab15bb6201de65376d0aa47cefb5.jpg",
+        "table_caption": [
+            "Table 7: Same as Tab. 1, but for CNN on IMDB dataset. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>H|F</td><td>Test acc.</td><td>Val. acc. (10)</td><td>Loss</td><td>Dist.</td></tr><tr><td>γ=0.1</td><td>5.91/1.94</td><td>88.83%</td><td>86.79</td><td>0.00031</td><td>13.24</td></tr><tr><td>γ = 1.0</td><td>4.19/1.45</td><td>88.79%</td><td>84.52</td><td>0.00029</td><td>14.04</td></tr><tr><td>γ =5.0</td><td>2.36/0.79</td><td>88.37%</td><td>78.32</td><td>0.00023</td><td>16.85</td></tr></table>",
+        "bbox": [
+            267,
+            127,
+            730,
+            194
+        ],
+        "page_idx": 18
+    }
+]

parse/train/Skk3Jm96W/Skk3Jm96W.md

@@ -0,0 +1,278 @@
+# SOME CONSIDERATIONS ON LEARNING TO EXPLORE VIA META-REINFORCEMENT LEARNING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+We consider the problem of exploration in meta reinforcement learning. Two new meta reinforcement learning algorithms are suggested: E-MAML and E-RL2. Results are presented on a novel environment we call ‘Krazy World’ and a set of maze environments. We show E-MAML and $\mathtt { E } \mathrm { - R L } ^ { 2 }$ deliver better performance on tasks where exploration is important.
+
+# 1 INTRODUCTION
+
+Supervised learning algorithms typically have their accuracy measured against some held-out test set which did not appear at training time. A supervised learning model generalizes well if it maintains its accuracy under data that has non-trivial dissimilarity from the training data. This approach to evaluating algorithms based on their generalization ability contrasts the approach in reinforcement learning (RL), wherein there is usually no distinction between training and testing environments. Instead, an agent is trained on one environment, and results are reported on this same environment. Most RL algorithms thus favor mastery over generalization.
+
+Meta RL is the suggestion that RL should take generalization seriously. In Meta RL, agents are evaluated on their ability to quickly master new environments at test time. Thus, a meta RL agent must not learn how to master the environments it is given, but rather it must learn how to learn so that it can quickly train at test time. Recent advances in meta RL have introduced algorithms that are capable of generating large policy improvements at test time with minimal sample complexity requirements Finn et al. (2017); Duan et al. (2016); Wang et al. (2016).
+
+One key question for meta RL that has been inadequately considered by Finn et al. (2017); Duan et al. (2016) is that of exploration (see Kompella et al. (2002) for an overview of exploration in this context). A crucial step in learning to solve many environments is an initial period of exploration and system identification. Furthermore, we know that real-life agents become better at this exploratory phase with practice. Consider, for example, an individual playing an entirely new video game. They will first need to identify the objective of the game and its mechanics. Further, we would expect that individuals who have played many video games would have a significantly easier time learning new games. Similarly, we would expect a good meta RL agent to become more efficient at this exploratory period. Unfortunately, we have found existing algorithms deficient in this area. We hypothesize that this failure can at least partially be attributed to the tendency of existing algorithms to do greedy, local optimization at each step of meta-training, as discussed further below.
+
+To address the problem of exploration in meta RL, we introduce two new algorithms: E-MAML and $\scriptstyle \mathrm { E - R L ^ { 2 } }$ . It should come as no surprise that these algorithms are similar to their respective namesakes MAML and $\mathrm { { R L } ^ { 2 } }$ . The algorithms are derived by reformulating the underlying meta-learning objective to account for the impact of initial sampling on future (post-meta-updated) returns. We show that our algorithms achieve better results than MAML and $\mathtt { R L } ^ { 2 }$ on two environments: a Krazy World environment we developed to benchmark meta RL, and a set of maze environments. In the appendix to this work, we consider a more general form of our E-MAML derivation. This more general derivation suggests several promising directions for future work on exploration in meta-learning and highlights the novelty of our contributions.
+
+# 2 RELATED WORK
+
+Recently, a flurry of new work in Deep Reinforcement Learning has provided the foundations for tackling RL problems that were previously thought intractable. This work includes: 1) Mnih et al. (2015; 2016); Koutnk et al. (2013), which allow for discrete control in complex environments directly from raw images. 2) Schulman et al. (2015); Mnih et al. (2016); Schulman et al. (2017); Lillicrap et al. (2015), which have allowed for high-dimensional continuous control in complex environments from raw state information.
+
+Although these algorithms offer impressive capabilities, they still often falter when faced with environments where exploration presents a significant challenge. This is not surprising, as there exists a large body of RL work addressing the exploration problem (Kearns & Singh, 2002; Brafman & Tennenholtz, 2002; Kolter & Ng, 2009). In practice, these methods are often not used due to difficulties with high-dimensional observations, difficulty in implementation on arbitrary domains, and lack of promising results (though recent work such as Schmidhuber (2015a) has seen progress in this regard). This resulted in most deep RL work utilizing epsilon greedy exploration (Mnih et al., 2015), or perhaps a simple scheme like Boltzmann exploration (Carmel & Markovitch, 1999). As a result of these shortcomings, a variety of new approaches to exploration in deep RL have recently been suggested (Tang et al., 2016; Houthooft et al., 2016; Stadie et al., 2015; Osband et al., 2016; Bellemare et al., 2016; Ostrovski et al., 2017). Further, there has been extensive research on the idea of artificial curiosity. For example Ngo et al. (2012); Graziano et al. (2011); Schmidhuber (1991; 2015b); Storck et al. (1995); Sun et al. (2011) all deal with teaching agents to generate a curiosity signal that aids in exploration. The work Kompella et al. (2002) even considers the problem of curiosity in the context of meta-RL via Success Story Algorithms (SSA). These algorithms use dynamic programming to explicitly partition experience into checkpoints and serve as a precursor to MAML and $\mathrm { { R L } ^ { 2 } }$ , which are less focused on explicitly partitioning episodes and more focused on handling high dimensional input Schmidhuber et al. (1997). In spite of the numerous cited efforts in the above paragraph, the problem of exploration in RL remains difficult.
+
+This paper will consider the problem of exploration in meta RL. However, it is important to note that many of the problems in meta RL can alternatively be addressed with the field of hierarchical reinforcement learning. In hierarchical RL, a major focus is on learning primitives that can be reused and strung together. These primitives will frequently enable better exploration, since they’ll often relate to better coverage over state visitation frequencies. Recent work in this direction includes (Vezhnevets et al., 2017; Bacon & Precup, 2015; Tessler et al., 2016; Rusu et al., 2016; Barto & Mahadevan, 2003; Wiering & Schmidhuber, 1997). The primary reason we consider meta learning over hierarchical RL is that we find hierarchical RL tends to focus more on defining specific architectures that should lead to hierarchical behavior, whereas meta learning instead attempts to directly optimize for these behaviors.
+
+As for meta RL itself, the literature is spread out and goes by many different names. There exist relevant literature on life-long learning, learning to learn, continual learning, and multi-task learning. Consider for instance Schmidhuber (2006; 1987). These papers deal with self modifying learning machines or genetic programs. In particular, they propose that if you have a genetic program that itself modifies the underlying genetic program, you will obtain a meta-GP approach (see appendix B for some clarification of this approach to the the algorithms presented in this paper). These methods describe an extremely broad class of algorithms which could be said to encompass most metalearning approaches with the correct interpretation. In addition to these references, we encourage the reviewer to look at the review articles Silver et al. (2013); Taylor & Stone (2009); Thrun (1996) and their citations. Most attempts to address exploration in these contexts has focused on curiosity or on a free learning phrase during training. Curiosity is addressed above, and is quite different from this work because it focuses on defining an intrinsic motivation signal, whereas we only consider better utilization of the existing reward signal. This paper’s methods share more similarities with free learning phases, though our algorithm makes a more explicit connection between this phase and the more exploitative phase of training (directly incorporating this information into the gradient updates).
+
+This paper will seek to capture insights from this prior literature and apply them to recently developed algorithms. In particular, we will consider considering E-MAML and $\mathtt { E } \mathrm { - } \mathtt { R } \mathrm { L } ^ { 2 }$ , which build upon the existing meta learning algorithms MAML (Finn et al., 2017) and $\mathrm { { R L } ^ { 2 } }$ (Duan et al., 2016).
+
+In MAML, tasks are sampled and a policy gradient update is computed for each task with respect to a fixed initial set of parameters. Subsequently, a meta update is performed where a gradient step is taken that moves the initial parameter in a direction that would have maximally benefited the average return over all of the sub-updates. Results are presented on an environment wherein a simulated ant must determine its goal direction, which changes each time a new task is sampled. In $\mathrm { { R L } ^ { 2 } }$ , an RNN is made to ingest multiple episodes from many different MDPs and then perform a policy gradient update through the entire temporal span of the RNN. The hope is that the RNN will learn a faster RL algorithm in its memory weights.
+
+# 3 REINFORCEMENT LEARNING NOTATION
+
+Let $M = ( \mathcal { S } , \mathcal { A } , \mathcal { P } , r , \rho _ { 0 } , \gamma , T )$ represent a discrete-time finite-horizon discounted Markov decision process (MDP). The elements of $M$ have the following definitions: $s$ is a state set, $\mathcal { A }$ an action set, $\mathcal { P } : \mathcal { S } \times \mathcal { A } \times \mathcal { S } \to \mathbb { R } _ { + }$ a transition probability distribution, $r : \mathcal { S } \times \mathcal { A }  \mathbb { R }$ a reward function, $\rho _ { 0 } : { \mathcal { S } } \to \mathbb { R } _ { + }$ an initial state distribution, $\gamma \in [ 0 , 1 ]$ a discount factor, and $T$ the horizon. We will sometimes speak of $M$ having a loss function $\mathcal { L }$ rather than reward function $r$ . All we mean here is that $\mathcal { L } ( s ) = - r ( s )$
+
+In a classical reinforcement learning setting, we optimize to obtain a set of parameters $\theta$ which maximize the expected discounted return under the policy $\pi _ { \theta } : S \times \mathcal { A }  \mathbb { R } _ { + }$ . That is, we optimize to obtain $\theta$ that maximizes $\begin{array} { r } { \eta ( \pi _ { \theta } ) = \mathbb { E } _ { \pi _ { \theta } } [ \sum _ { t = 0 } ^ { T } \gamma ^ { t } r ( s _ { t } ) ] } \end{array}$ , where $s _ { 0 } \sim \rho _ { 0 } ( s _ { 0 } )$ , $a _ { t } \sim \pi _ { \theta } ( a _ { t } | s _ { t } )$ , and $s _ { t + 1 } \sim \mathcal { P } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ .
+
+# 4 PROBLEM FORMULATION AND ALGORITHMS
+
+# 4.1 THE META REINFORCEMENT LEARNING OBJECTIVE
+
+In meta reinforcement learning, we consider a family of MDPs $\mathcal { M } = \{ M _ { i } \} _ { i = 1 } ^ { N }$ which comprise a distribution of tasks. The goal of meta RL is to find a policy $\pi _ { \theta }$ and paired update method $U$ such that, given $M _ { i } \sim \mathcal { M }$ , we have $\pi _ { U \left( \theta \right) }$ solves $M _ { i }$ quickly. The word quickly is important here, so let us elaborate. By quickly, we mean orders of magnitude more sample efficient than simply solving $M _ { i }$ with policy gradient or value iteration methods. In fact, an ideal meta RL algorithm would solve these tasks by collecting 1-10 trajectories from the environment for tasks where policy gradients require 100,000 or more trajectories. The thinking here goes that if an algorithm can solve a problem with so few samples, then it might be ‘learning to learn.’ That is, the agent is not learning how to master a given task but rather how to quickly master new tasks. We can write this objective cleanly as
+
+$$
+\operatorname* { m i n } _ { \theta } \sum _ { M _ { i } } \mathbb { E } _ { ( \pi _ { U ( \theta ) } ) } \left[ \mathcal { L } _ { M _ { i } } \right]
+$$
+
+Note that this objective is similar to the one that appears in MAML Finn et al. (2017), which we will discuss further below. In MAML, $U$ is chosen to be the stochastic gradient descent.
+
+# 4.2 E-MAML
+
+We can expand the expectation from (1) into the integral
+
+$$
+\int R ( \tau ) \pi _ { U ( \theta ) } ( \tau ) \mathrm { d } \tau
+$$
+
+The objective (1) can be optimized by taking a derivative of this integral with respect to $\theta$ and carrying out a standard REINFORCE style analysis to obtain a tractable expression for the gradient Williams (1992).
+
+One issue with this direct optimization is that it will not account for the impact of the original sampling distribution $\pi _ { \theta }$ on the future rewards $R ( \tau ) , \tau \sim \pi _ { U ( \theta ) }$ . We would like to account for this, because it would allow us to weight the initial samples $\bar { \tau } \sim \pi _ { \theta }$ by the expected future returns we expect after the sampling update $R ( \tau )$ . More importantly, this extra-term reinforces particular explorative trajectories if the updated agent learn well in the end. On the contrary when this term is abscent, good exploratory behaviors will not be encouraged.
+
+Including this dependency can be done by writing the modified expectation as
+
+$$
+\int \int R ( \tau ) \pi _ { U ( \theta ) } ( \tau ) \pi _ { \theta } ( \bar { \tau } ) \mathrm { d } \bar { \tau } \mathrm { d } \tau
+$$
+
+Note that one could certainly argue that this is the correct form of (2), and that the failure to include the dependency above makes (2) incomplete. We choose to view both as valid approaches, with (3) simply being the more exploratory version of the objective for reasons discussed above.
+
+In any case, we find ourselves wishing to find a tractable expression for the gradient of (3). This can be done quite smoothly by applying the product rule under the integral sign and going through the REINFORCE style derivation twice to arrive at a two term expression, one of which encourages exploitation and one of which encourages exploration.
+
+$$
+\begin{array} { r l } {  { \frac { \partial } { \partial \theta } \iint { R ( \tau ) \pi _ { U ( \theta ) } ( \tau ) \pi _ { \theta } ( \bar { \tau } ) \mathrm { d } \bar { \tau } \mathrm { d } \tau } } } \\ & { = \iint { R ( \tau ) [ \pi _ { \theta } ( \bar { \tau } ) \frac { \partial } { \partial \theta } \pi _ { U ( \theta ) } ( \tau ) + \pi _ { U ( \theta ) } ( \tau ) \frac { \partial } { \partial \theta } \pi _ { \theta } ( \bar { \tau } ) ] \mathrm { d } \bar { \tau } \mathrm { d } \tau } } \\ & { \approx \displaystyle \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { R ( \tau ^ { i } ) \frac { \partial } { \partial \theta } \log \pi _ { U ( \theta ) } ( \tau ^ { i } ) + \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { R ( \tau ^ { i } ) \frac { \partial } { \partial \theta } \log \pi _ { \theta } ( \bar { \tau } ^ { i } ) } } | _ { \tau ^ { i } \sim \pi _ { \theta } ( \tau ^ { i } ) } | _ { \tau ^ { i } \sim \pi _ { U ( \theta ) } ( \tau ^ { i } ) } } \\ & { \approx \displaystyle \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { R ( \tau ^ { i } ) \frac { \partial } { \partial \theta } \log \pi _ { U ( \theta ) } ( \tau ^ { i } ) + \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { R ( \tau ^ { i } ) \frac { \partial } { \partial \theta } \log \pi _ { \theta } ( \bar { \tau } ^ { i } ) } } | _ { \tau ^ { i } \sim \pi _ { U ( \theta ) } ( \tau ^ { i } ) } | _ { \tau ^ { i } \sim \pi _ { U ( \theta ) } ( \tau ^ { i } ) } } \\ &  \approx \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { R ( \tau ^ { i } ) \frac { \partial } { \partial \theta } \log \pi _ { U ( \theta ) } ( \tau ^ { i } ) + \frac { 1 } { T } \sum _ { i = 1 } ^ { T } { R ( \tau ^ { i } ) \frac { \partial } { \partial \theta } \log \pi _ { \theta } ( \bar { \tau } ^ { i } ) } } | _ { \tau ^ { i } \sim \pi _ { U ( \theta ) } ( \tau ^ { i } ) } | _  \tau ^ { i } \sim \pi _ { U ( \theta ) } \end{array}
+$$
+
+Note that, if we only consider the term on the left, we arrive at the original MAML algorithm Finn et al. (2017). This term encourages the agent to take update steps $U$ that achieve good final rewards. It is exploitative. The second term encourages the agent to take actions such that the eventual metaupdate yields good rewards (crucially, it does not try and exploit the reward signal under its own trajectory $\bar { \tau }$ ). This term allows the policy to be more exploratory, as it will attempt to deliver the maximal amount of information useful for the future rewards $R ( \tau )$ without worrying about its own rewards $R ( \bar { \tau } )$ . Since this algorithm augments MAML by adding in an exploratory term, we call it E-MAML. For the experiments presented in this paper, we will assume that $U$ utilized in MAML and E-MAML is stochastic gradient descent. However, we direct the reader to the appendix for an insightful discussion on the choice of $U$ .
+
+# 4.3 E-RL2
+
+$\mathrm { { R L } ^ { 2 } }$ optimizes (1) by feeding multiple rollouts from multiple different MDPs into an RNN. The hope is that the RNN hidden state update $h _ { t } = C ( x _ { t } , h _ { t - 1 } )$ , will learn to act as the update function $U$ . Then, performing a policy gradient update on the RNN will correspond to optimizing the meta objective (1).
+
+We can write the $\mathrm { { R L } ^ { 2 } }$ update rule more explicitly in the following way. Suppose $L$ represents an RNN. Let $\mathrm { E n v } _ { k } ( a )$ be a function that takes an action, uses it to interact with the MDP representing task $k$ , and returns the next observation $\boldsymbol { o } ^ { 1 }$ , reward $r$ , and a termination flag $d$ . Then we have
+
+$$
+\begin{array} { c } { x _ { t } = \left[ o _ { t - 1 } , a _ { t - 1 } , r _ { t - 1 } , d _ { t - 1 } \right] } \\ { \left[ a _ { t } , h _ { t + 1 } \right] = L ( h _ { t } , x _ { t } ) } \\ { \left[ o _ { t } , r _ { t } , d _ { t } \right] = \mathrm { E n v } _ { k } ( a _ { t } ) } \end{array}
+$$
+
+To train this RNN, we sample $N$ MDPs from $\mathcal { M }$ and obtain $k$ rollouts for each MDP by running the MDP through the RNN as above. We then compute a policy gradient update to move the RNN parameters in a direction which maximizes the returns over the $k$ trials performed for each MDP.
+
+To make this algorithm more exploratory, we can take inspiration from the insights shone by EMAML. For each MDP $M _ { i }$ , we will sample $p$ exploratory rollouts and $k - p$ non-exploratory rollouts. During an exploratory rollout, the forward pass through the RNN will receive all information.
+
+However, during the backwards pass, the rewards contributed during exploratory episodes will be set to zero. For example, if there is one exploratory episode and one exploitative episode, then we would proceed as follows. During the forward pass, the RNN will receive all information regarding rewards for both episodes. During the backwards pass, the returns will be computed as
+
+$$
+R ( x _ { i } ) = \sum _ { j = i } ^ { T } \gamma ^ { j } r _ { j } \cdot \chi _ { E } ( x _ { j } )
+$$
+
+Where $\chi _ { E }$ is an indicator that returns 0 if the episode is exploratory and 1 otherwise. This return, and not the standard sum of discounted returns, is what is used to compute the policy gradient. The hope is that zeroing the return contributions from exploratory episodes will encourage the RNN to treat its initial rollouts as exploratory, taking actions which may not lead to immediate rewards but rather to the RNN hidden weights performing better system identification, which will lead to higher rewards in later episodes.
+
+# 5 EXPERIMENTS
+
+# 5.1 KRAZY WORLD ENVIRONMENT
+
+To test the ability of meta RL algorithms to explore, we introduce a new environment known as Krazy World.
+
+![](images/ab01d604ada7961841e7fef228cde25258d787cc1d4f01fbb2f9444ef37304f3.jpg)  
+Figure 1: Three example worlds drawn from the task distribution. The agent must first perform an exploratory stage of system identification before exploiting. For example, in the leftmost grid the agent must first identify that the orange squares give $+ 1$ reward and the blue squares replenish its limited supply of energy. Further, it will need to identify that the gold squares block progress and the black square can only be passed by picking up the pink key. The agent may also want to identify that the brown squares will kill it and that it will slide over the purple squares. The other center and right worlds show these assignments will change and need to be re-identified every time a new task is drawn.
+
+This environment has the following features:
+
+1. 8 different tile types: Goal squares provide $+ 1$ reward when retrieved. The agent reaching the goal does not cause the episode to terminate, and there can be multiple goals. Ice squares will be skipped over in the direction the agent is transversing. Death squares will kill the agent and end the episode. Wall squares act as a wall, impeding the agent’s movement. Lock squares can only be passed once the agent has collected the corresponding key from a key square. Teleporter squares transport the agent to a different teleporter square on the map. Energy squares provide the agent with additional energy. If the agent runs out of energy, it can no longer move. The agent proceeds normally across normal squares.
+
+2. Ability to randomly swap color palette: The color palette for the grid can be randomly permuted, changing the color that corresponds to each of the different tile types. The agent will thus have to identify the new system to achieve a high score. Note that in representations of the gird wherein basis vectors are used rather than images to describe the state space, each basis vector will correspond to a tile type, and permuting the colors will correspond to permuting the types of tiles these basis vectors represent. We prefer to use the basis vector representation in our experiments, as it is more sample efficient.
+
+3. Ability to randomly swap dynamics: The game’s dynamics can be altered. The most naive alteration simply permutes the player’s inputs and corresponding actions (issuing the command for down moves the player up etc). More complex dynamics alterations allow the agent to move multiple steps at a time in arbitrary directions, making the movement more akin to that of chess pieces.
+
+4. Local or Global Observations: The agent’s observation space can be set to some fixed number of squares around the agent, the squares in front of the agent, or the entire grid. Observations can be given as images or as a grid of basis vectors. For the case of basis vectors, each element of the grid is embedded as a basis vector that corresponds to that tile type. These embeddings are then concatenated together to form the observation proper. We will use local observations.
+
+![](images/12b723d4070d025023c80d403ff4947faf57dd1883442583f3bf89151647ddc1.jpg)  
+Figure 2: A comparison of local and global observations for the Krazy World environment. In the local mode, the agent only views a $3 \times 3$ grid centered about itself. In global mode, the agent views the entire environment.
+
+A successful meta learning agent will first need to explore the environment, identifying the different tile types, color palette, and dynamics. A meta learning algorithm that cannot learn to incorporate exploration into its quick updating strategy will ultimately have insufficient data to navigate the game. We see this empirically in our experiments below.
+
+# 5.2 MAZES
+
+A collection of maze environments. The agent is placed at a random square within the maze and must learn to navigate the twists and turns to reach the goal square. A good exploratory agent will spend some time learning the maze’s layout in a way that minimizes repetition of future mistakes. The mazes are not rendered, and consequently this task is done with state space only. The mazes are $2 0 \times 2 0$ squares large.
+
+![](images/7affb13f5cefc95f6fc9c6f7bffc96a7d951d5e3ff7c988beff24f19ef8ed2d0.jpg)  
+Figure 3: One example maze environment rendered in human readable format. The agent attempts to find a goal within the maze.
+
+# 5.3 RESULTS
+
+In this section we present the following experimental results.
+
+1. Learning curves on Krazy World and mazes.
+
+2. The gap between the agent’s initial performance on new environments and its performance after updating. A good meta learning algorithm will have a large gap after updating. A standard RL algorithm will have virtually no gap after only one update.
+
+3. Three heuristic metrics for how well the algorithms explore.
+
+![](images/2b91dc490917207fae208f08b7fc44efe888ade72f2cd89523e8ae15adcc58f2.jpg)  
+Figure 4: Meta learning curves on Krazy World. We see that ${ \bf - R L ^ { 2 } }$ is at times closest to the optimal solution of 0.6 (obtained via value iteration), but has the highest initial variance. E-MAML converges faster than MAML, although both algorithms do manage to converge. $\mathtt { R L } ^ { 2 }$ has relatively poor performance and high variance. A random agent achieves a score of around 0.05 on this task.
+
+For both Krazy World and mazes, training proceeds in the following way. First, we initialize 32 training environments and 64 test environments. Every initialized environment has a different seed. Next, we initialize our chosen meta-RL algorithm by uniformly sampling hyper-parameters from predefined ranges. Data is then collected from all 32 training environments. The meta-RL algorithm then uses this data to make a meta-update, as detailed in the algorithm section of this paper. The meta-RL algorithm is then allowed to do one training step on the 64 test environments to see how fast it can train at test time. These test environment results are recorded, 32 new tasks are sampled from the training environments, and data collection begins again. For MAML and E-MAML, training at test time means performing one VPG update at test time (see the appendix for evidence that taking only one gradient step is sufficient). For $\mathrm { { R L } ^ { 2 } }$ and $\mathrm { E } { \mathrm { - } } \mathrm { R } \mathrm { L } ^ { 2 }$ , this means running three exploratory episodes to allow the RNN memory weights time to update and then reporting the loss on the fourth and fifth episodes. For both algorithms, meta-updates are calculated with PPO Schulman et al. (2017). The entire process from the above paragraph is repeated from the beginning 64 times and the results are averaged to provide the final learning curves featured in this paper.
+
+When plotting learning curves in Figure 4 and Figure 5, the $\mathrm { Y }$ axis is the reward obtained after training at test time on a set of 64 held-out test environments. The X axis is the total number of environmental time-steps the algorithm has used for training. Every time the environment advances forward by one step, this count increments by one. This is done to keep the time-scale consistent across meta-learning curves.
+
+For Krazy World, learning curves are presented in Figure 4. We see that E-MAML and E-RL2 have the best final performance. E-MAML has the steepest initial gains for the first 10 million time-steps. Since meta-learning algorithms are often very expensive, having a steep initial ascent is quite valuable. Around 14 million training steps, E-RL2 passes E-MAML for the best performance. By 25 million time-steps, $\mathtt { E } \mathrm { - R L } ^ { 2 }$ is somewhat close to the optimal solution (obtained via value iteration). However, it appears to have converged below this value. MAML delivers comparable final performance to E-MAML, suggesting that perhaps MAML also learns to explore sufficiently well on this task. However, it takes it much longer to obtain this level of performance. Finally, $\mathrm { { R L } ^ { 2 } }$ has comparatively poor performance on this task and very high variance. When we manually examined the $\mathtt { R L } ^ { 2 }$ trajectories to figure out why, we saw the agent consistently finding a single goal square and then refusing to explore any further. The exploration metrics presented below seem consistent with this finding.
+
+Learning curves for mazes are presented in Figure 5. Here, the story is different than Krazy World. $\mathrm { { R L } ^ { 2 } }$ and $\mathtt { E } \mathrm { - } \mathtt { R } \mathtt { L } ^ { 2 }$ both perform better than MAML and E-MAML. We suspect the reason for this is that RNNs are able to leverage memory, which is more important in mazes than in Krazy World. This environment carries a penalty for hitting the wall, which MAML and E-MAML discover quickly. However, it takes $\scriptstyle \mathrm { E - R L } ^ { 2 }$ and $\mathrm { { R L } ^ { 2 } }$ much longer to discover this penalty, resulting in worse performance at the beginning of training. MAML delivers worse final performance and typically only learns how to avoid hitting the wall. $\mathrm { { R L } ^ { 2 } }$ and E-MAML sporadically solve mazes. E-RL2 manages to solve many of the mazes.
+
+![](images/91f048f624f6022f7ab1eb6786af5c9bf8374ed1c33d5cc91d68815f54c5ceba.jpg)  
+Figure 5: Meta learning curves on mazes. The environment gives the agent a penalty for hitting the wall. Interestingly, $\mathsf { \bar { E } } \mathrm { - R L } ^ { 2 }$ and $\mathrm { { R L } ^ { 2 } }$ take much longer to learn how to avoid the wall. However, they also deliver better final performance. $\scriptstyle \mathrm { E - R L ^ { 2 } }$ learns faster than $\mathrm { { R L } ^ { 2 } }$ and offers superior final performance. Since MAML and E-MAML utilize MLPs instead of RNNs and have no memory, their worse returns are not surprising. The optimal return for this task would be around 1.1 (obtained via value iteration) and a random agent would achieve a return of around -2.2 (mostly from hitting the wall). Note that this figure appears somewhat busy due to having all four algorithms on one graph. Figure 6 shows each curve in isolation, making it easier to discern their individual characteristics.
+
+When examining meta learning algorithms, one important metric is the update size after one learning episode. Our meta learning algorithms should have a large gap between their initial policy, which is largely exploratory, and their updated policy, which should often solve the problem entirely. For MAML, we look at the gap between the initial policy and the policy after one policy gradient step (see the appendix for information on further gradient steps). For $\mathrm { { R L } ^ { 2 } }$ , we look at the results after three exploratory episodes, which give the RNN hidden state $h$ sufficient time to update. Note that three is the number of exploratory episodes we used during training as well. This metric shares similarities with the Jump Start metric considered in prior litearture Taylor & Stone (2009). These gaps are presented in 6.
+
+Finally, in Figure 7 we consider three heuristic metrics for measuring the exploratory ability of the meta-learners. First, we consider the fraction of tile types visited by the agent at test time. Our intuition is that good exploratory agents will visit and identify many different tile types as this should aid in optimally solving the game. Second, we consider the number of times an agent visits a death tile at test time. Agents that are efficient at exploring should visit this tile type exactly once and then avoid it. We often find that more naive agents will run into these tiles repeatedly, causing their death many times over and a sense of pity in any onlookers. Finally, we look at how many goals the agent reaches. We see that $\mathtt { R L } ^ { 2 }$ tends to visit fewer goals and instead tend to stick with a strategy of finding one goal and exploiting it. Overall, we see that the exploratory algorithms achieve better performance under these metrics.
+
+![](images/a11440d4be249faa4cbe306e1febd8b48c219bc8d95c6ee47cc5fc96e7496f14.jpg)  
+Figure 6: Looking at the gap between initial performance and performance after one update for $\mathrm { { R L } ^ { 2 } }$ , $\mathtt { E } \mathrm { - } \mathtt { R } \mathtt { L } ^ { 2 }$ , MAML, and E-MAML. All algorithms show some level of improvement after one update, which suggests the meta-learning is working. On Krazy World, the gap between the initial policy performance and updated policy performance is fairly large for all algorithms. Interestingly, the initial performance of all algorithms on gridworld is similar, converging to values around 0.1. However, E-MAML and $\mathtt { R L } ^ { 2 }$ tend to have the highest variance. Meanwhile, for mazes, we see the gap between initial and update policy returns for MAML and E-MAML is unfortunately small. Perhaps this is because these algorithms do not have a memory, which makes the maze task more difficult. For $\mathrm { { R L } ^ { 2 } }$ and $\mathtt { E } \mathrm { - } \mathtt { R } \mathtt { L } ^ { 2 }$ the gap is bigger, with E-RL2 delivering the best improvement.
+
+# 6 CONCLUSION
+
+We considered the problem of exploration in meta reinforcement learning. Two new algorithms were derived and their properties were analyzed. In particular, we showed that these algorithms tend to learn more quickly and explore more efficiently than existing algorithms. It is likely that future work in this area will focus on meta-learning a curiosity signal which is robust and transfers across tasks. Perhaps this will enable meta agents which learn to explore rather than being forced to explore by mathematical trickery in their objectives. See appendix B for more explicit discussion on possible future directions.
+
+![](images/afb8ca7ac2c74fb9f1560f59747c1b0fbe31601ece9718d0a37fb6fa9aca157a.jpg)  
+Figure 7: Three heuristic metrics for exploration on Krazy World: Fraction of tile types visited during test time, number of times killed at a death square during test time, and number of goal squares visited. We see that E-MAML is consistently the most diligent algorithm at checking every tile type during test time. Beyond that, things are fuzzy with $\mathtt { R L } ^ { 2 }$ and MAML both checking a majority of tile types at test time and $\scriptstyle \mathrm { E - R L ^ { 2 } }$ being sporadic in this regard. As for the number of times the death tile type was visited, we see that most algorithms start by dying in all three test episodes, and subsequently decrease to between one and two by the time they have converged. As mentioned above, $\mathrm { { R L } ^ { 2 } }$ suffers from finding one goal and exploiting it, whereas the other algorithms regularly explore to find more goals. For the most part, the exploratory algorithms consistently deliver the best performance on these metrics. Performance on the death heuristic and the tile types found heuristic seem to indicate the meta learners are learning how to do at least some system identification.
+
+# REFERENCES
+
+P. Bacon and D. Precup. The option-critic architecture. In NIPS Deep RL Workshop, 2015.
+
+Barto and Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete Event Dynamic Systems, 2003.
+
+M. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying count based exploration and intrinsic motivation. NIPS, 2016.
+
+R. I. Brafman and M. Tennenholtz. R-max - a general polynomial time algorithm for near-optimal reinforcement learning. Journal of Machine Learning Research, 2002.   
+D. Carmel and S. Markovitch. Exploration strategies for model-based learning in multi-agent systems. Autonomous Agents and Multi-Agent Systems, 1999.   
+Y. Duan, J. Schulman, X. Chen, P. L. Bartlett, I. Sutskever, and P. Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.   
+C. Finn, P. Abbeel, and S. Levine. Model-agnostic metalearning for fast adaptation of deep networks. ICML, 2017.   
+Vincent Graziano, Tobias Glasmachers, Tom Schaul, Leo Pape, Giuseppe Cuccu, Jurgen Leitner, and Jurgen Schmidhuber. Artificial Curiosity for Autonomous Space Exploration. ¨ Acta Futura, 1(1): 41–51, 2011. doi: 10.2420/AF04.2011.41. URL http://dx.doi.org/10.2420/AF04. 2011.41.   
+R. Houthooft, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. Vime: Variational information maximizing exploration. NIPS, 2016.   
+M. J. Kearns and S. P. Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 2002.   
+J. Z. Kolter and A. Y. Ng. Near-bayesian exploration in polynomial time. ICML, 2009.   
+Kompella, Stollenga, Luciw, and Schmidhuber. Exploring the predictable. Advances in Evolutionary Computing, 2002.   
+Jan Koutnk, Giuseppe Cuccu, Jrgen Schmidhuber, and Faustino Gomez. Evolving large-scale neural networks for vision-based reinforcement learning. GECCO 2013, 15:1061–1068, 2013.   
+T. Lillicrap, J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra. Continuous control with deep reinforcement learning. arXiv:1509.02971, 2015.   
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.   
+Volodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv:1602.01783, 2016.   
+Hung Ngo, Matthew Luciw, Alexander Forster, and Juergen Schmidhuber. Learning skills from play: Artificial curiosity on a Katana robot arm. Proceedings of the International Joint Conference on Neural Networks, pp. 10–15, 2012. ISSN 2161-4393. doi: 10.1109/IJCNN.2012.6252824.   
+I. Osband, C. Blundell, A. Pritzel, and B. Van Roy. Deep exploration via bootstrapped dqn. NIPS, 2016.   
+G. Ostrovski, M. G. Bellemare, A. v. d. Oord, and R. Munos. Count-based exploration with neural density models. arXiv:1703.01310, 2017.   
+A. A. Rusu, N. C. Rabinowitz, G. Desjardins, H. Soyer, J. Kirkpatrick, K. Kavukcuoglu, R. Pascanu, and R. Hadsell. Progressive neural networks. CoRR, vol. abs/1606.04671, 2016.   
+Schmidhuber. Evolutionary principles in self-referential learning, or on learning how to learn: The meta-meta-... hook. Diploma thesis, TUM, 1987.   
+Schmidhuber. Gdel machines: Fully self-referential optimal universal self-improvers. Artificial General Intelligence, 2006.   
+J. Schmidhuber. Continual curiosity-driven skill acquisition from high-dimensional video inputs for humanoid robots. Artificial Intelligence, 2015a.
+
+J. Schmidhuber, J. Zhao, and N. Schraudolph. Reinforcement learning with self-modifying policies. Learning to learn, Kluwer, 1997.
+
+Juergen Schmidhuber. On Learning to Think: Algorithmic Information Theory for Novel Combinations of Reinforcement Learning Controllers and Recurrent Neural World Models. pp. 1– 36, 2015b. ISSN 10450823. doi: 1511.09249v1. URL http://arxiv.org/abs/1511. 09249.
+
+Jurgen Schmidhuber. A Possibility for Implementing Curiosity and Boredom in Model-Building ¨ Neural Controllers. Meyer, J.A. and Wilson, S.W. (eds) : From Animals to animats, pp. 222–227, 1991.
+
+J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. arXiv:1707.06347, 2017.
+
+John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. Arxiv preprint 1502.05477, 2015.
+
+Silver, Yand, and Li. Lifelong machine learning systems: Beyond learning algorithms. DAAAI Spring Symposium-Technical Report, 2013., 2013.
+
+Bradly C. Stadie, S. Levine, and P. Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv:1507.00814, 2015.
+
+Jan Storck, Sepp Hochreiter, and Jurgen Schmidhuber. Reinforcement driven information acquisi- ¨ tion in non-deterministic environments. Proceedings of the International . . . , 2:159–164, 1995.
+
+Yi Sun, Faustino Gomez, and Jurgen Schmidhuber. Planning to be surprised: Optimal Bayesian ¨ exploration in dynamic environments. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 6830 LNAI:41–51, 2011. ISSN 03029743. doi: 10.1007/978-3-642-22887-2 5.
+
+H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. exploration: A study of count-based exploration for deep reinforcement learning. arXiv:1611.04717, 2016.
+
+Taylor and Stone. Transfer learning for reinforcement learning domains: A survey. DAAAI Spring Symposium-Technical Report, 2013., 2009.
+
+S. Tessler, C. Givony, T. Zahavy, D.J. Mankowitz, and S. Mannor. A deep hierarchical approach to lifelong learning in minecraft. arXiv:1604.07255, 2016.
+
+Thrun. Is learning the n-th thing any easier than learning the first? NIPS, 1996.
+
+A. S. Vezhnevets, S. Osindero, T. Schaul, N. Heess, M. Jaderberg, D. Silver, and K. Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. arXiv preprint arXiv:1703.01161, 2017.
+
+J. X. Wang, Z. Kurth-Nelson, D. Tirumala, H. Soyer, J. Z. Leibo, R. Munos, C. Blundell, D. Kumaran, and M. Botvinick. Learning to reinforcement learn. arXiv:1611.05763, 2016.
+
+Wiering and Schmidhuber. Hq-learning. Adaptive Behavior, 1997.
+
+Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning 8, 3-4 (1992), 229256, 1992.
+
+# 7 APPENDIX A: MAML REWARDS VS NUMBER OF GRADIENT STEPS
+
+In the experiment, only 1-step of gradient descent is done in the MAML variants. However, we have explored doing multiple steps of PPO SGD for each task. Example screenshots of multiple gradient update during training are shown below.
+
+![](images/1105976585ce84a1dd34b7fba623d734a12ee79bc5f26ade1c0e47e6bcdd6778.jpg)  
+Figure 8: MAML on the right and E-MAML on the left. A look at the number of gradient steps at test time vs reward on the Krazy World environment. Both MAML and E-MAML do not typically benefit from seeing more than one gradient step at test time. Hence, we only perform one gradient step at test time for the experiments in this paper.
+
+# 8 APPENDIX B: E-MAML EXPLORATION AS A CHOICE
+
+The path-integral formulation of the expected reward in E-MAML is
+
+$$
+\mathcal { L } ( \boldsymbol { \theta } _ { 0 } ) = - \int \int R ( \tau ) \cdot \pi ( a _ { i } | s _ { i } , U ( \boldsymbol { \theta } _ { 0 } , R ( \bar { \tau } ) , \bar { \tau } \sim \pi ( a | \boldsymbol { \theta } _ { 0 } ) ) ) \cdot \pi ( \bar { a } _ { i } | \bar { s } _ { i } , \boldsymbol { \theta } _ { 0 } ) \mathrm { d } \tau \mathrm { d } \bar { \tau } .
+$$
+
+We can make it easier to tell the role of $U$ by re-writing the action probability $\pi$ and $U$ in type notation where
+
+$$
+\hat { \pi } ( \theta ) : \Rightarrow \{ ( \tau ) : \mathbb { R } ^ { + } \Rightarrow \pi ( a _ { t } | s _ { t } , \theta ) \} \quad \mathrm { a n d } \quad \hat { U } ( \theta _ { 0 } ) : \Theta \Rightarrow U \bigg ( \theta _ { 0 } , R ( \tau ) , \tau \sim \pi ( a | \theta _ { 0 } ) \bigg ) ,
+$$
+
+$\hat { \pi }$ returns a function on trajectories $\tau \in \mathcal { T }$ , whereas $\hat { U }$ takes in two more variables from it’s closure, and returns an updated $\theta \in \Theta$ . Using the Polish notation $@$ applied from-left-to-right, the surrogate loss could be written as
+
+$$
+\mathcal { L } ( \theta _ { 0 } ) = - \iint _ { \mathbf { \Omega } } R ( \tau ) \cdot \Big ( \hat { \pi } \circ \hat { U } \Big ) { \ @ \theta _ { 0 } \ @ \bar { \tau } \cdot \hat { \pi } \ @ \theta _ { 0 } \ @ \bar { \tau } } \mathrm { d } \tau \mathrm { d } \bar { \tau } .
+$$
+
+In this notation, it becomes clear that you could pick any arbitrary function for the inner-update operator $\hat { U }$ . Under this context, the update operator of choice in E-MAML (and similarly MAML) is an instance from a more general class of exploratory operators $\mathcal { O }$ :
+
+$$
+\hat { U } _ { \mathrm { M A M L } } ( \mathrm {  ~ \lambda ~ } ) : \Theta \Rightarrow \mathrm { S G D } \biggl ( \mathcal { L } _ { \mathrm { P P O } } , \tau ( \pi ( \mathrm {  ~ \lambda ~ } ) ) , \biggr )
+$$
+
+where the class of operators it belongs to is $\hat { U } _ { \mathrm { M A M L } } \in \mathcal { O } : \{ ( \Theta ) : \Rightarrow \Theta \}$
+
+So what is this PPO/VPG update operator? One could argue that $U _ { \mathrm { M A M L } }$ is a “reward-maximizing” exploration strategy. The reward collected during the exploration phase is used to compute the gradient direction for $\theta _ { 0 }$ , which is in-turn used to update $\theta _ { 0 } \to \theta$ .
+
+Then it becomes immediately obvious there are a few other operators that could also be plugged in:
+
+• random exploration on a single task, where $\theta$ is perturbed randomly.   
+• natural gradient on a single task, where such perturbation is scaled with the inverse fisher information.   
+• perpendicular to gradient: Another extreme is to update the initial parameter $\theta _ { 0 }$ perpendicular to the gradient direction.   
+• $\varepsilon$ -greedy: A middle ground between these extremes is a $\varepsilon$ -greedy exploration strategy, where for $\varepsilon$ of the time the per-task exploration is done randomly, whereas for the rest of the time $( 1 - \varepsilon )$ the gradient direction is picked.   
+Meta-learned Exploratory Operator where the inner-update operator $U$ is learned to optimality to a specific class of tasks. See Schmidhuber (2006; 1987). Distraction-free Learning where the sign of the explorative log probability is flipped. This should discourage exploratory behavior. This could be useful in a life-long learning agent during test time, where exploration is extremely costly.
+
+We are planning on exploring these directions in the future.

parse/train/Skk3Jm96W/Skk3Jm96W_content_list.json

@@ -0,0 +1,1358 @@
+[
+    {
+        "type": "text",
+        "text": "SOME CONSIDERATIONS ON LEARNING TO EXPLORE VIA META-REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            823,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            184,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider the problem of exploration in meta reinforcement learning. Two new meta reinforcement learning algorithms are suggested: E-MAML and E-RL2. Results are presented on a novel environment we call ‘Krazy World’ and a set of maze environments. We show E-MAML and $\\mathtt { E } \\mathrm { - R L } ^ { 2 }$ deliver better performance on tasks where exploration is important. ",
+        "bbox": [
+            232,
+            277,
+            766,
+            347
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            402,
+            336,
+            417
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Supervised learning algorithms typically have their accuracy measured against some held-out test set which did not appear at training time. A supervised learning model generalizes well if it maintains its accuracy under data that has non-trivial dissimilarity from the training data. This approach to evaluating algorithms based on their generalization ability contrasts the approach in reinforcement learning (RL), wherein there is usually no distinction between training and testing environments. Instead, an agent is trained on one environment, and results are reported on this same environment. Most RL algorithms thus favor mastery over generalization. ",
+        "bbox": [
+            174,
+            443,
+            825,
+            541
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Meta RL is the suggestion that RL should take generalization seriously. In Meta RL, agents are evaluated on their ability to quickly master new environments at test time. Thus, a meta RL agent must not learn how to master the environments it is given, but rather it must learn how to learn so that it can quickly train at test time. Recent advances in meta RL have introduced algorithms that are capable of generating large policy improvements at test time with minimal sample complexity requirements Finn et al. (2017); Duan et al. (2016); Wang et al. (2016). ",
+        "bbox": [
+            173,
+            547,
+            825,
+            632
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "One key question for meta RL that has been inadequately considered by Finn et al. (2017); Duan et al. (2016) is that of exploration (see Kompella et al. (2002) for an overview of exploration in this context). A crucial step in learning to solve many environments is an initial period of exploration and system identification. Furthermore, we know that real-life agents become better at this exploratory phase with practice. Consider, for example, an individual playing an entirely new video game. They will first need to identify the objective of the game and its mechanics. Further, we would expect that individuals who have played many video games would have a significantly easier time learning new games. Similarly, we would expect a good meta RL agent to become more efficient at this exploratory period. Unfortunately, we have found existing algorithms deficient in this area. We hypothesize that this failure can at least partially be attributed to the tendency of existing algorithms to do greedy, local optimization at each step of meta-training, as discussed further below. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            791
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To address the problem of exploration in meta RL, we introduce two new algorithms: E-MAML and $\\scriptstyle \\mathrm { E - R L ^ { 2 } }$ . It should come as no surprise that these algorithms are similar to their respective namesakes MAML and $\\mathrm { { R L } ^ { 2 } }$ . The algorithms are derived by reformulating the underlying meta-learning objective to account for the impact of initial sampling on future (post-meta-updated) returns. We show that our algorithms achieve better results than MAML and $\\mathtt { R L } ^ { 2 }$ on two environments: a Krazy World environment we developed to benchmark meta RL, and a set of maze environments. In the appendix to this work, we consider a more general form of our E-MAML derivation. This more general derivation suggests several promising directions for future work on exploration in meta-learning and highlights the novelty of our contributions. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            343,
+            117
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, a flurry of new work in Deep Reinforcement Learning has provided the foundations for tackling RL problems that were previously thought intractable. This work includes: 1) Mnih et al. (2015; 2016); Koutnk et al. (2013), which allow for discrete control in complex environments directly from raw images. 2) Schulman et al. (2015); Mnih et al. (2016); Schulman et al. (2017); Lillicrap et al. (2015), which have allowed for high-dimensional continuous control in complex environments from raw state information. ",
+        "bbox": [
+            174,
+            145,
+            825,
+            229
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Although these algorithms offer impressive capabilities, they still often falter when faced with environments where exploration presents a significant challenge. This is not surprising, as there exists a large body of RL work addressing the exploration problem (Kearns & Singh, 2002; Brafman & Tennenholtz, 2002; Kolter & Ng, 2009). In practice, these methods are often not used due to difficulties with high-dimensional observations, difficulty in implementation on arbitrary domains, and lack of promising results (though recent work such as Schmidhuber (2015a) has seen progress in this regard). This resulted in most deep RL work utilizing epsilon greedy exploration (Mnih et al., 2015), or perhaps a simple scheme like Boltzmann exploration (Carmel & Markovitch, 1999). As a result of these shortcomings, a variety of new approaches to exploration in deep RL have recently been suggested (Tang et al., 2016; Houthooft et al., 2016; Stadie et al., 2015; Osband et al., 2016; Bellemare et al., 2016; Ostrovski et al., 2017). Further, there has been extensive research on the idea of artificial curiosity. For example Ngo et al. (2012); Graziano et al. (2011); Schmidhuber (1991; 2015b); Storck et al. (1995); Sun et al. (2011) all deal with teaching agents to generate a curiosity signal that aids in exploration. The work Kompella et al. (2002) even considers the problem of curiosity in the context of meta-RL via Success Story Algorithms (SSA). These algorithms use dynamic programming to explicitly partition experience into checkpoints and serve as a precursor to MAML and $\\mathrm { { R L } ^ { 2 } }$ , which are less focused on explicitly partitioning episodes and more focused on handling high dimensional input Schmidhuber et al. (1997). In spite of the numerous cited efforts in the above paragraph, the problem of exploration in RL remains difficult. ",
+        "bbox": [
+            174,
+            236,
+            825,
+            500
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper will consider the problem of exploration in meta RL. However, it is important to note that many of the problems in meta RL can alternatively be addressed with the field of hierarchical reinforcement learning. In hierarchical RL, a major focus is on learning primitives that can be reused and strung together. These primitives will frequently enable better exploration, since they’ll often relate to better coverage over state visitation frequencies. Recent work in this direction includes (Vezhnevets et al., 2017; Bacon & Precup, 2015; Tessler et al., 2016; Rusu et al., 2016; Barto & Mahadevan, 2003; Wiering & Schmidhuber, 1997). The primary reason we consider meta learning over hierarchical RL is that we find hierarchical RL tends to focus more on defining specific architectures that should lead to hierarchical behavior, whereas meta learning instead attempts to directly optimize for these behaviors. ",
+        "bbox": [
+            173,
+            507,
+            825,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "As for meta RL itself, the literature is spread out and goes by many different names. There exist relevant literature on life-long learning, learning to learn, continual learning, and multi-task learning. Consider for instance Schmidhuber (2006; 1987). These papers deal with self modifying learning machines or genetic programs. In particular, they propose that if you have a genetic program that itself modifies the underlying genetic program, you will obtain a meta-GP approach (see appendix B for some clarification of this approach to the the algorithms presented in this paper). These methods describe an extremely broad class of algorithms which could be said to encompass most metalearning approaches with the correct interpretation. In addition to these references, we encourage the reviewer to look at the review articles Silver et al. (2013); Taylor & Stone (2009); Thrun (1996) and their citations. Most attempts to address exploration in these contexts has focused on curiosity or on a free learning phrase during training. Curiosity is addressed above, and is quite different from this work because it focuses on defining an intrinsic motivation signal, whereas we only consider better utilization of the existing reward signal. This paper’s methods share more similarities with free learning phases, though our algorithm makes a more explicit connection between this phase and the more exploitative phase of training (directly incorporating this information into the gradient updates). ",
+        "bbox": [
+            174,
+            654,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This paper will seek to capture insights from this prior literature and apply them to recently developed algorithms. In particular, we will consider considering E-MAML and $\\mathtt { E } \\mathrm { - } \\mathtt { R } \\mathrm { L } ^ { 2 }$ , which build upon the existing meta learning algorithms MAML (Finn et al., 2017) and $\\mathrm { { R L } ^ { 2 } }$ (Duan et al., 2016). ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In MAML, tasks are sampled and a policy gradient update is computed for each task with respect to a fixed initial set of parameters. Subsequently, a meta update is performed where a gradient step is taken that moves the initial parameter in a direction that would have maximally benefited the average return over all of the sub-updates. Results are presented on an environment wherein a simulated ant must determine its goal direction, which changes each time a new task is sampled. In $\\mathrm { { R L } ^ { 2 } }$ , an RNN is made to ingest multiple episodes from many different MDPs and then perform a policy gradient update through the entire temporal span of the RNN. The hope is that the RNN will learn a faster RL algorithm in its memory weights. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 REINFORCEMENT LEARNING NOTATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            236,
+            540,
+            252
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $M = ( \\mathcal { S } , \\mathcal { A } , \\mathcal { P } , r , \\rho _ { 0 } , \\gamma , T )$ represent a discrete-time finite-horizon discounted Markov decision process (MDP). The elements of $M$ have the following definitions: $s$ is a state set, $\\mathcal { A }$ an action set, $\\mathcal { P } : \\mathcal { S } \\times \\mathcal { A } \\times \\mathcal { S } \\to \\mathbb { R } _ { + }$ a transition probability distribution, $r : \\mathcal { S } \\times \\mathcal { A }  \\mathbb { R }$ a reward function, $\\rho _ { 0 } : { \\mathcal { S } } \\to \\mathbb { R } _ { + }$ an initial state distribution, $\\gamma \\in [ 0 , 1 ]$ a discount factor, and $T$ the horizon. We will sometimes speak of $M$ having a loss function $\\mathcal { L }$ rather than reward function $r$ . All we mean here is that $\\mathcal { L } ( s ) = - r ( s )$ ",
+        "bbox": [
+            173,
+            266,
+            825,
+            352
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In a classical reinforcement learning setting, we optimize to obtain a set of parameters $\\theta$ which maximize the expected discounted return under the policy $\\pi _ { \\theta } : S \\times \\mathcal { A }  \\mathbb { R } _ { + }$ . That is, we optimize to obtain $\\theta$ that maximizes $\\begin{array} { r } { \\eta ( \\pi _ { \\theta } ) = \\mathbb { E } _ { \\pi _ { \\theta } } [ \\sum _ { t = 0 } ^ { T } \\gamma ^ { t } r ( s _ { t } ) ] } \\end{array}$ , where $s _ { 0 } \\sim \\rho _ { 0 } ( s _ { 0 } )$ , $a _ { t } \\sim \\pi _ { \\theta } ( a _ { t } | s _ { t } )$ , and $s _ { t + 1 } \\sim \\mathcal { P } ( s _ { t + 1 } | s _ { t } , a _ { t } )$ . ",
+        "bbox": [
+            174,
+            357,
+            825,
+            417
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 PROBLEM FORMULATION AND ALGORITHMS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            436,
+            580,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.1 THE META REINFORCEMENT LEARNING OBJECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            468,
+            578,
+            483
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In meta reinforcement learning, we consider a family of MDPs $\\mathcal { M } = \\{ M _ { i } \\} _ { i = 1 } ^ { N }$ which comprise a distribution of tasks. The goal of meta RL is to find a policy $\\pi _ { \\theta }$ and paired update method $U$ such that, given $M _ { i } \\sim \\mathcal { M }$ , we have $\\pi _ { U \\left( \\theta \\right) }$ solves $M _ { i }$ quickly. The word quickly is important here, so let us elaborate. By quickly, we mean orders of magnitude more sample efficient than simply solving $M _ { i }$ with policy gradient or value iteration methods. In fact, an ideal meta RL algorithm would solve these tasks by collecting 1-10 trajectories from the environment for tasks where policy gradients require 100,000 or more trajectories. The thinking here goes that if an algorithm can solve a problem with so few samples, then it might be ‘learning to learn.’ That is, the agent is not learning how to master a given task but rather how to quickly master new tasks. We can write this objective cleanly as ",
+        "bbox": [
+            173,
+            492,
+            825,
+            633
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e4e440ad094c35be376cb87b1bd1362f23b183eba3b21d312fa8aaabd1b348bd.jpg",
+        "text": "$$\n\\operatorname* { m i n } _ { \\theta } \\sum _ { M _ { i } } \\mathbb { E } _ { ( \\pi _ { U ( \\theta ) } ) } \\left[ \\mathcal { L } _ { M _ { i } } \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            640,
+            387,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Note that this objective is similar to the one that appears in MAML Finn et al. (2017), which we will discuss further below. In MAML, $U$ is chosen to be the stochastic gradient descent. ",
+        "bbox": [
+            173,
+            681,
+            823,
+            709
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4.2 E-MAML ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            727,
+            285,
+            741
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can expand the expectation from (1) into the integral ",
+        "bbox": [
+            174,
+            752,
+            544,
+            767
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dbc21a5debbe745ed1b3e2fa324900304b74bf6a8b5e4958a01a5b2898d6ee96.jpg",
+        "text": "$$\n\\int R ( \\tau ) \\pi _ { U ( \\theta ) } ( \\tau ) \\mathrm { d } \\tau\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            773,
+            366,
+            806
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The objective (1) can be optimized by taking a derivative of this integral with respect to $\\theta$ and carrying out a standard REINFORCE style analysis to obtain a tractable expression for the gradient Williams (1992). ",
+        "bbox": [
+            174,
+            813,
+            823,
+            854
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "One issue with this direct optimization is that it will not account for the impact of the original sampling distribution $\\pi _ { \\theta }$ on the future rewards $R ( \\tau ) , \\tau \\sim \\pi _ { U ( \\theta ) }$ . We would like to account for this, because it would allow us to weight the initial samples $\\bar { \\tau } \\sim \\pi _ { \\theta }$ by the expected future returns we expect after the sampling update $R ( \\tau )$ . More importantly, this extra-term reinforces particular explorative trajectories if the updated agent learn well in the end. On the contrary when this term is abscent, good exploratory behaviors will not be encouraged. ",
+        "bbox": [
+            174,
+            867,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Including this dependency can be done by writing the modified expectation as ",
+        "bbox": [
+            174,
+            138,
+            686,
+            154
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/33353279706c7ae1e5ab62d2973bd8e25b062906f6b150b0e000e9aaca9d974f.jpg",
+        "text": "$$\n\\int \\int R ( \\tau ) \\pi _ { U ( \\theta ) } ( \\tau ) \\pi _ { \\theta } ( \\bar { \\tau } ) \\mathrm { d } \\bar { \\tau } \\mathrm { d } \\tau\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            160,
+            433,
+            193
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that one could certainly argue that this is the correct form of (2), and that the failure to include the dependency above makes (2) incomplete. We choose to view both as valid approaches, with (3) simply being the more exploratory version of the objective for reasons discussed above. ",
+        "bbox": [
+            174,
+            207,
+            825,
+            248
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In any case, we find ourselves wishing to find a tractable expression for the gradient of (3). This can be done quite smoothly by applying the product rule under the integral sign and going through the REINFORCE style derivation twice to arrive at a two term expression, one of which encourages exploitation and one of which encourages exploration. ",
+        "bbox": [
+            176,
+            255,
+            823,
+            311
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e357905bcfe2967ccfcf7108b7115459d57aaf33482432653214d856c22eba1e.jpg",
+        "text": "$$\n\\begin{array} { r l } {  { \\frac { \\partial } { \\partial \\theta } \\iint { R ( \\tau ) \\pi _ { U ( \\theta ) } ( \\tau ) \\pi _ { \\theta } ( \\bar { \\tau } ) \\mathrm { d } \\bar { \\tau } \\mathrm { d } \\tau } } } \\\\ & { = \\iint { R ( \\tau ) [ \\pi _ { \\theta } ( \\bar { \\tau } ) \\frac { \\partial } { \\partial \\theta } \\pi _ { U ( \\theta ) } ( \\tau ) + \\pi _ { U ( \\theta ) } ( \\tau ) \\frac { \\partial } { \\partial \\theta } \\pi _ { \\theta } ( \\bar { \\tau } ) ] \\mathrm { d } \\bar { \\tau } \\mathrm { d } \\tau } } \\\\ & { \\approx \\displaystyle \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { R ( \\tau ^ { i } ) \\frac { \\partial } { \\partial \\theta } \\log \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) + \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { R ( \\tau ^ { i } ) \\frac { \\partial } { \\partial \\theta } \\log \\pi _ { \\theta } ( \\bar { \\tau } ^ { i } ) } } | _ { \\tau ^ { i } \\sim \\pi _ { \\theta } ( \\tau ^ { i } ) } | _ { \\tau ^ { i } \\sim \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) } } \\\\ & { \\approx \\displaystyle \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { R ( \\tau ^ { i } ) \\frac { \\partial } { \\partial \\theta } \\log \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) + \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { R ( \\tau ^ { i } ) \\frac { \\partial } { \\partial \\theta } \\log \\pi _ { \\theta } ( \\bar { \\tau } ^ { i } ) } } | _ { \\tau ^ { i } \\sim \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) } | _ { \\tau ^ { i } \\sim \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) } } \\\\ &  \\approx \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { R ( \\tau ^ { i } ) \\frac { \\partial } { \\partial \\theta } \\log \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) + \\frac { 1 } { T } \\sum _ { i = 1 } ^ { T } { R ( \\tau ^ { i } ) \\frac { \\partial } { \\partial \\theta } \\log \\pi _ { \\theta } ( \\bar { \\tau } ^ { i } ) } } | _ { \\tau ^ { i } \\sim \\pi _ { U ( \\theta ) } ( \\tau ^ { i } ) } | _  \\tau ^ { i } \\sim \\pi _ { U ( \\theta ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            318,
+            717,
+            435
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that, if we only consider the term on the left, we arrive at the original MAML algorithm Finn et al. (2017). This term encourages the agent to take update steps $U$ that achieve good final rewards. It is exploitative. The second term encourages the agent to take actions such that the eventual metaupdate yields good rewards (crucially, it does not try and exploit the reward signal under its own trajectory $\\bar { \\tau }$ ). This term allows the policy to be more exploratory, as it will attempt to deliver the maximal amount of information useful for the future rewards $R ( \\tau )$ without worrying about its own rewards $R ( \\bar { \\tau } )$ . Since this algorithm augments MAML by adding in an exploratory term, we call it E-MAML. For the experiments presented in this paper, we will assume that $U$ utilized in MAML and E-MAML is stochastic gradient descent. However, we direct the reader to the appendix for an insightful discussion on the choice of $U$ . ",
+        "bbox": [
+            173,
+            441,
+            825,
+            580
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.3 E-RL2 ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            597,
+            261,
+            612
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "$\\mathrm { { R L } ^ { 2 } }$ optimizes (1) by feeding multiple rollouts from multiple different MDPs into an RNN. The hope is that the RNN hidden state update $h _ { t } = C ( x _ { t } , h _ { t - 1 } )$ , will learn to act as the update function $U$ . Then, performing a policy gradient update on the RNN will correspond to optimizing the meta objective (1). ",
+        "bbox": [
+            173,
+            623,
+            825,
+            681
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We can write the $\\mathrm { { R L } ^ { 2 } }$ update rule more explicitly in the following way. Suppose $L$ represents an RNN. Let $\\mathrm { E n v } _ { k } ( a )$ be a function that takes an action, uses it to interact with the MDP representing task $k$ , and returns the next observation $\\boldsymbol { o } ^ { 1 }$ , reward $r$ , and a termination flag $d$ . Then we have ",
+        "bbox": [
+            174,
+            686,
+            825,
+            729
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/efcb10108863873e52a6578ab0bc3cf8f1cb977a8f8b6ff3ca20c4af4b42894f.jpg",
+        "text": "$$\n\\begin{array} { c } { x _ { t } = \\left[ o _ { t - 1 } , a _ { t - 1 } , r _ { t - 1 } , d _ { t - 1 } \\right] } \\\\ { \\left[ a _ { t } , h _ { t + 1 } \\right] = L ( h _ { t } , x _ { t } ) } \\\\ { \\left[ o _ { t } , r _ { t } , d _ { t } \\right] = \\mathrm { E n v } _ { k } ( a _ { t } ) } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            736,
+            475,
+            791
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To train this RNN, we sample $N$ MDPs from $\\mathcal { M }$ and obtain $k$ rollouts for each MDP by running the MDP through the RNN as above. We then compute a policy gradient update to move the RNN parameters in a direction which maximizes the returns over the $k$ trials performed for each MDP. ",
+        "bbox": [
+            173,
+            795,
+            825,
+            838
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To make this algorithm more exploratory, we can take inspiration from the insights shone by EMAML. For each MDP $M _ { i }$ , we will sample $p$ exploratory rollouts and $k - p$ non-exploratory rollouts. During an exploratory rollout, the forward pass through the RNN will receive all information. ",
+        "bbox": [
+            174,
+            844,
+            825,
+            887
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "However, during the backwards pass, the rewards contributed during exploratory episodes will be set to zero. For example, if there is one exploratory episode and one exploitative episode, then we would proceed as follows. During the forward pass, the RNN will receive all information regarding rewards for both episodes. During the backwards pass, the returns will be computed as ",
+        "bbox": [
+            174,
+            103,
+            825,
+            160
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/595fc84f11b834f7c06798c30e96bae173e75627895e5a73dbd99fa6e0ef5074.jpg",
+        "text": "$$\nR ( x _ { i } ) = \\sum _ { j = i } ^ { T } \\gamma ^ { j } r _ { j } \\cdot \\chi _ { E } ( x _ { j } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            166,
+            416,
+            213
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Where $\\chi _ { E }$ is an indicator that returns 0 if the episode is exploratory and 1 otherwise. This return, and not the standard sum of discounted returns, is what is used to compute the policy gradient. The hope is that zeroing the return contributions from exploratory episodes will encourage the RNN to treat its initial rollouts as exploratory, taking actions which may not lead to immediate rewards but rather to the RNN hidden weights performing better system identification, which will lead to higher rewards in later episodes. ",
+        "bbox": [
+            173,
+            219,
+            825,
+            304
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            325,
+            326,
+            342
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "5.1 KRAZY WORLD ENVIRONMENT ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            357,
+            434,
+            372
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To test the ability of meta RL algorithms to explore, we introduce a new environment known as Krazy World. ",
+        "bbox": [
+            176,
+            385,
+            823,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/ab01d604ada7961841e7fef228cde25258d787cc1d4f01fbb2f9444ef37304f3.jpg",
+        "image_caption": [
+            "Figure 1: Three example worlds drawn from the task distribution. The agent must first perform an exploratory stage of system identification before exploiting. For example, in the leftmost grid the agent must first identify that the orange squares give $+ 1$ reward and the blue squares replenish its limited supply of energy. Further, it will need to identify that the gold squares block progress and the black square can only be passed by picking up the pink key. The agent may also want to identify that the brown squares will kill it and that it will slide over the purple squares. The other center and right worlds show these assignments will change and need to be re-identified every time a new task is drawn. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            426,
+            825,
+            537
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "This environment has the following features: ",
+        "bbox": [
+            176,
+            683,
+            467,
+            696
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "1. 8 different tile types: Goal squares provide $+ 1$ reward when retrieved. The agent reaching the goal does not cause the episode to terminate, and there can be multiple goals. Ice squares will be skipped over in the direction the agent is transversing. Death squares will kill the agent and end the episode. Wall squares act as a wall, impeding the agent’s movement. Lock squares can only be passed once the agent has collected the corresponding key from a key square. Teleporter squares transport the agent to a different teleporter square on the map. Energy squares provide the agent with additional energy. If the agent runs out of energy, it can no longer move. The agent proceeds normally across normal squares. ",
+        "bbox": [
+            214,
+            709,
+            825,
+            820
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2. Ability to randomly swap color palette: The color palette for the grid can be randomly permuted, changing the color that corresponds to each of the different tile types. The agent will thus have to identify the new system to achieve a high score. Note that in representations of the gird wherein basis vectors are used rather than images to describe the state space, each basis vector will correspond to a tile type, and permuting the colors will correspond to permuting the types of tiles these basis vectors represent. We prefer to use the basis vector representation in our experiments, as it is more sample efficient. ",
+        "bbox": [
+            214,
+            827,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3. Ability to randomly swap dynamics: The game’s dynamics can be altered. The most naive alteration simply permutes the player’s inputs and corresponding actions (issuing the command for down moves the player up etc). More complex dynamics alterations allow the agent to move multiple steps at a time in arbitrary directions, making the movement more akin to that of chess pieces. ",
+        "bbox": [
+            212,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4. Local or Global Observations: The agent’s observation space can be set to some fixed number of squares around the agent, the squares in front of the agent, or the entire grid. Observations can be given as images or as a grid of basis vectors. For the case of basis vectors, each element of the grid is embedded as a basis vector that corresponds to that tile type. These embeddings are then concatenated together to form the observation proper. We will use local observations. ",
+        "bbox": [
+            214,
+            176,
+            825,
+            260
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/12b723d4070d025023c80d403ff4947faf57dd1883442583f3bf89151647ddc1.jpg",
+        "image_caption": [
+            "Figure 2: A comparison of local and global observations for the Krazy World environment. In the local mode, the agent only views a $3 \\times 3$ grid centered about itself. In global mode, the agent views the entire environment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            401,
+            268,
+            593,
+            342
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A successful meta learning agent will first need to explore the environment, identifying the different tile types, color palette, and dynamics. A meta learning algorithm that cannot learn to incorporate exploration into its quick updating strategy will ultimately have insufficient data to navigate the game. We see this empirically in our experiments below. ",
+        "bbox": [
+            174,
+            425,
+            825,
+            482
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.2 MAZES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            497,
+            266,
+            512
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "A collection of maze environments. The agent is placed at a random square within the maze and must learn to navigate the twists and turns to reach the goal square. A good exploratory agent will spend some time learning the maze’s layout in a way that minimizes repetition of future mistakes. The mazes are not rendered, and consequently this task is done with state space only. The mazes are $2 0 \\times 2 0$ squares large. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            593
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/7affb13f5cefc95f6fc9c6f7bffc96a7d951d5e3ff7c988beff24f19ef8ed2d0.jpg",
+        "image_caption": [
+            "Figure 3: One example maze environment rendered in human readable format. The agent attempts to find a goal within the maze. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            346,
+            613,
+            650,
+            856
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5.3 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            103,
+            279,
+            117
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this section we present the following experimental results. ",
+        "bbox": [
+            173,
+            130,
+            573,
+            145
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "1. Learning curves on Krazy World and mazes. ",
+        "bbox": [
+            214,
+            156,
+            524,
+            171
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "2. The gap between the agent’s initial performance on new environments and its performance after updating. A good meta learning algorithm will have a large gap after updating. A standard RL algorithm will have virtually no gap after only one update. ",
+        "bbox": [
+            215,
+            176,
+            825,
+            218
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3. Three heuristic metrics for how well the algorithms explore. ",
+        "bbox": [
+            210,
+            223,
+            627,
+            238
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/2b91dc490917207fae208f08b7fc44efe888ade72f2cd89523e8ae15adcc58f2.jpg",
+        "image_caption": [
+            "Figure 4: Meta learning curves on Krazy World. We see that ${ \\bf - R L ^ { 2 } }$ is at times closest to the optimal solution of 0.6 (obtained via value iteration), but has the highest initial variance. E-MAML converges faster than MAML, although both algorithms do manage to converge. $\\mathtt { R L } ^ { 2 }$ has relatively poor performance and high variance. A random agent achieves a score of around 0.05 on this task. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            233,
+            258,
+            756,
+            468
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For both Krazy World and mazes, training proceeds in the following way. First, we initialize 32 training environments and 64 test environments. Every initialized environment has a different seed. Next, we initialize our chosen meta-RL algorithm by uniformly sampling hyper-parameters from predefined ranges. Data is then collected from all 32 training environments. The meta-RL algorithm then uses this data to make a meta-update, as detailed in the algorithm section of this paper. The meta-RL algorithm is then allowed to do one training step on the 64 test environments to see how fast it can train at test time. These test environment results are recorded, 32 new tasks are sampled from the training environments, and data collection begins again. For MAML and E-MAML, training at test time means performing one VPG update at test time (see the appendix for evidence that taking only one gradient step is sufficient). For $\\mathrm { { R L } ^ { 2 } }$ and $\\mathrm { E } { \\mathrm { - } } \\mathrm { R } \\mathrm { L } ^ { 2 }$ , this means running three exploratory episodes to allow the RNN memory weights time to update and then reporting the loss on the fourth and fifth episodes. For both algorithms, meta-updates are calculated with PPO Schulman et al. (2017). The entire process from the above paragraph is repeated from the beginning 64 times and the results are averaged to provide the final learning curves featured in this paper. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "When plotting learning curves in Figure 4 and Figure 5, the $\\mathrm { Y }$ axis is the reward obtained after training at test time on a set of 64 held-out test environments. The X axis is the total number of environmental time-steps the algorithm has used for training. Every time the environment advances forward by one step, this count increments by one. This is done to keep the time-scale consistent across meta-learning curves. ",
+        "bbox": [
+            174,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For Krazy World, learning curves are presented in Figure 4. We see that E-MAML and E-RL2 have the best final performance. E-MAML has the steepest initial gains for the first 10 million time-steps. Since meta-learning algorithms are often very expensive, having a steep initial ascent is quite valuable. Around 14 million training steps, E-RL2 passes E-MAML for the best performance. By 25 million time-steps, $\\mathtt { E } \\mathrm { - R L } ^ { 2 }$ is somewhat close to the optimal solution (obtained via value iteration). However, it appears to have converged below this value. MAML delivers comparable final performance to E-MAML, suggesting that perhaps MAML also learns to explore sufficiently well on this task. However, it takes it much longer to obtain this level of performance. Finally, $\\mathrm { { R L } ^ { 2 } }$ has comparatively poor performance on this task and very high variance. When we manually examined the $\\mathtt { R L } ^ { 2 }$ trajectories to figure out why, we saw the agent consistently finding a single goal square and then refusing to explore any further. The exploration metrics presented below seem consistent with this finding. ",
+        "bbox": [
+            173,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Learning curves for mazes are presented in Figure 5. Here, the story is different than Krazy World. $\\mathrm { { R L } ^ { 2 } }$ and $\\mathtt { E } \\mathrm { - } \\mathtt { R } \\mathtt { L } ^ { 2 }$ both perform better than MAML and E-MAML. We suspect the reason for this is that RNNs are able to leverage memory, which is more important in mazes than in Krazy World. This environment carries a penalty for hitting the wall, which MAML and E-MAML discover quickly. However, it takes $\\scriptstyle \\mathrm { E - R L } ^ { 2 }$ and $\\mathrm { { R L } ^ { 2 } }$ much longer to discover this penalty, resulting in worse performance at the beginning of training. MAML delivers worse final performance and typically only learns how to avoid hitting the wall. $\\mathrm { { R L } ^ { 2 } }$ and E-MAML sporadically solve mazes. E-RL2 manages to solve many of the mazes. ",
+        "bbox": [
+            173,
+            194,
+            825,
+            305
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/91f048f624f6022f7ab1eb6786af5c9bf8374ed1c33d5cc91d68815f54c5ceba.jpg",
+        "image_caption": [
+            "Figure 5: Meta learning curves on mazes. The environment gives the agent a penalty for hitting the wall. Interestingly, $\\mathsf { \\bar { E } } \\mathrm { - R L } ^ { 2 }$ and $\\mathrm { { R L } ^ { 2 } }$ take much longer to learn how to avoid the wall. However, they also deliver better final performance. $\\scriptstyle \\mathrm { E - R L ^ { 2 } }$ learns faster than $\\mathrm { { R L } ^ { 2 } }$ and offers superior final performance. Since MAML and E-MAML utilize MLPs instead of RNNs and have no memory, their worse returns are not surprising. The optimal return for this task would be around 1.1 (obtained via value iteration) and a random agent would achieve a return of around -2.2 (mostly from hitting the wall). Note that this figure appears somewhat busy due to having all four algorithms on one graph. Figure 6 shows each curve in isolation, making it easier to discern their individual characteristics. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            235,
+            320,
+            758,
+            526
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When examining meta learning algorithms, one important metric is the update size after one learning episode. Our meta learning algorithms should have a large gap between their initial policy, which is largely exploratory, and their updated policy, which should often solve the problem entirely. For MAML, we look at the gap between the initial policy and the policy after one policy gradient step (see the appendix for information on further gradient steps). For $\\mathrm { { R L } ^ { 2 } }$ , we look at the results after three exploratory episodes, which give the RNN hidden state $h$ sufficient time to update. Note that three is the number of exploratory episodes we used during training as well. This metric shares similarities with the Jump Start metric considered in prior litearture Taylor & Stone (2009). These gaps are presented in 6. ",
+        "bbox": [
+            173,
+            680,
+            825,
+            805
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, in Figure 7 we consider three heuristic metrics for measuring the exploratory ability of the meta-learners. First, we consider the fraction of tile types visited by the agent at test time. Our intuition is that good exploratory agents will visit and identify many different tile types as this should aid in optimally solving the game. Second, we consider the number of times an agent visits a death tile at test time. Agents that are efficient at exploring should visit this tile type exactly once and then avoid it. We often find that more naive agents will run into these tiles repeatedly, causing their death many times over and a sense of pity in any onlookers. Finally, we look at how many goals the agent reaches. We see that $\\mathtt { R L } ^ { 2 }$ tends to visit fewer goals and instead tend to stick with a strategy of finding one goal and exploiting it. Overall, we see that the exploratory algorithms achieve better performance under these metrics. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/a11440d4be249faa4cbe306e1febd8b48c219bc8d95c6ee47cc5fc96e7496f14.jpg",
+        "image_caption": [
+            "Figure 6: Looking at the gap between initial performance and performance after one update for $\\mathrm { { R L } ^ { 2 } }$ , $\\mathtt { E } \\mathrm { - } \\mathtt { R } \\mathtt { L } ^ { 2 }$ , MAML, and E-MAML. All algorithms show some level of improvement after one update, which suggests the meta-learning is working. On Krazy World, the gap between the initial policy performance and updated policy performance is fairly large for all algorithms. Interestingly, the initial performance of all algorithms on gridworld is similar, converging to values around 0.1. However, E-MAML and $\\mathtt { R L } ^ { 2 }$ tend to have the highest variance. Meanwhile, for mazes, we see the gap between initial and update policy returns for MAML and E-MAML is unfortunately small. Perhaps this is because these algorithms do not have a memory, which makes the maze task more difficult. For $\\mathrm { { R L } ^ { 2 } }$ and $\\mathtt { E } \\mathrm { - } \\mathtt { R } \\mathtt { L } ^ { 2 }$ the gap is bigger, with E-RL2 delivering the best improvement. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            173,
+            111,
+            818,
+            756
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            151,
+            318,
+            167
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We considered the problem of exploration in meta reinforcement learning. Two new algorithms were derived and their properties were analyzed. In particular, we showed that these algorithms tend to learn more quickly and explore more efficiently than existing algorithms. It is likely that future work in this area will focus on meta-learning a curiosity signal which is robust and transfers across tasks. Perhaps this will enable meta agents which learn to explore rather than being forced to explore by mathematical trickery in their objectives. See appendix B for more explicit discussion on possible future directions. ",
+        "bbox": [
+            173,
+            183,
+            825,
+            279
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/afb8ca7ac2c74fb9f1560f59747c1b0fbe31601ece9718d0a37fb6fa9aca157a.jpg",
+        "image_caption": [
+            "Figure 7: Three heuristic metrics for exploration on Krazy World: Fraction of tile types visited during test time, number of times killed at a death square during test time, and number of goal squares visited. We see that E-MAML is consistently the most diligent algorithm at checking every tile type during test time. Beyond that, things are fuzzy with $\\mathtt { R L } ^ { 2 }$ and MAML both checking a majority of tile types at test time and $\\scriptstyle \\mathrm { E - R L ^ { 2 } }$ being sporadic in this regard. As for the number of times the death tile type was visited, we see that most algorithms start by dying in all three test episodes, and subsequently decrease to between one and two by the time they have converged. As mentioned above, $\\mathrm { { R L } ^ { 2 } }$ suffers from finding one goal and exploiting it, whereas the other algorithms regularly explore to find more goals. For the most part, the exploratory algorithms consistently deliver the best performance on these metrics. Performance on the death heuristic and the tile types found heuristic seem to indicate the meta learners are learning how to do at least some system identification. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            300,
+            816,
+            598
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            815,
+            285,
+            830
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "P. Bacon and D. Precup. The option-critic architecture. In NIPS Deep RL Workshop, 2015. ",
+        "bbox": [
+            171,
+            837,
+            767,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Barto and Mahadevan. Recent advances in hierarchical reinforcement learning. Discrete Event Dynamic Systems, 2003. ",
+        "bbox": [
+            173,
+            859,
+            821,
+            887
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. Bellemare, S. Srinivasan, G. Ostrovski, T. Schaul, D. Saxton, and R. Munos. Unifying count based exploration and intrinsic motivation. NIPS, 2016. ",
+        "bbox": [
+            169,
+            895,
+            825,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "R. I. Brafman and M. Tennenholtz. R-max - a general polynomial time algorithm for near-optimal reinforcement learning. Journal of Machine Learning Research, 2002.   \nD. Carmel and S. Markovitch. Exploration strategies for model-based learning in multi-agent systems. Autonomous Agents and Multi-Agent Systems, 1999.   \nY. Duan, J. Schulman, X. Chen, P. L. Bartlett, I. Sutskever, and P. Abbeel. Rl2: Fast reinforcement learning via slow reinforcement learning. arXiv preprint arXiv:1611.02779, 2016.   \nC. Finn, P. Abbeel, and S. Levine. Model-agnostic metalearning for fast adaptation of deep networks. ICML, 2017.   \nVincent Graziano, Tobias Glasmachers, Tom Schaul, Leo Pape, Giuseppe Cuccu, Jurgen Leitner, and Jurgen Schmidhuber. Artificial Curiosity for Autonomous Space Exploration. ¨ Acta Futura, 1(1): 41–51, 2011. doi: 10.2420/AF04.2011.41. URL http://dx.doi.org/10.2420/AF04. 2011.41.   \nR. Houthooft, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. Vime: Variational information maximizing exploration. NIPS, 2016.   \nM. J. Kearns and S. P. Singh. Near-optimal reinforcement learning in polynomial time. Machine Learning, 2002.   \nJ. Z. Kolter and A. Y. Ng. Near-bayesian exploration in polynomial time. ICML, 2009.   \nKompella, Stollenga, Luciw, and Schmidhuber. Exploring the predictable. Advances in Evolutionary Computing, 2002.   \nJan Koutnk, Giuseppe Cuccu, Jrgen Schmidhuber, and Faustino Gomez. Evolving large-scale neural networks for vision-based reinforcement learning. GECCO 2013, 15:1061–1068, 2013.   \nT. Lillicrap, J. Hunt, A. Pritzel, N. Heess, T. Erez, Y. Tassa, D. Silver, and D. Wierstra. Continuous control with deep reinforcement learning. arXiv:1509.02971, 2015.   \nVolodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning. Nature, 518(7540):529–533, 2015.   \nVolodymyr Mnih, Adria Puigdomenech Badia, Mehdi Mirza, Alex Graves, Timothy P Lillicrap, Tim Harley, David Silver, and Koray Kavukcuoglu. Asynchronous methods for deep reinforcement learning. arXiv:1602.01783, 2016.   \nHung Ngo, Matthew Luciw, Alexander Forster, and Juergen Schmidhuber. Learning skills from play: Artificial curiosity on a Katana robot arm. Proceedings of the International Joint Conference on Neural Networks, pp. 10–15, 2012. ISSN 2161-4393. doi: 10.1109/IJCNN.2012.6252824.   \nI. Osband, C. Blundell, A. Pritzel, and B. Van Roy. Deep exploration via bootstrapped dqn. NIPS, 2016.   \nG. Ostrovski, M. G. Bellemare, A. v. d. Oord, and R. Munos. Count-based exploration with neural density models. arXiv:1703.01310, 2017.   \nA. A. Rusu, N. C. Rabinowitz, G. Desjardins, H. Soyer, J. Kirkpatrick, K. Kavukcuoglu, R. Pascanu, and R. Hadsell. Progressive neural networks. CoRR, vol. abs/1606.04671, 2016.   \nSchmidhuber. Evolutionary principles in self-referential learning, or on learning how to learn: The meta-meta-... hook. Diploma thesis, TUM, 1987.   \nSchmidhuber. Gdel machines: Fully self-referential optimal universal self-improvers. Artificial General Intelligence, 2006.   \nJ. Schmidhuber. Continual curiosity-driven skill acquisition from high-dimensional video inputs for humanoid robots. Artificial Intelligence, 2015a. ",
+        "bbox": [
+            169,
+            65,
+            828,
+            931
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "J. Schmidhuber, J. Zhao, and N. Schraudolph. Reinforcement learning with self-modifying policies. Learning to learn, Kluwer, 1997. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Juergen Schmidhuber. On Learning to Think: Algorithmic Information Theory for Novel Combinations of Reinforcement Learning Controllers and Recurrent Neural World Models. pp. 1– 36, 2015b. ISSN 10450823. doi: 1511.09249v1. URL http://arxiv.org/abs/1511. 09249. ",
+        "bbox": [
+            173,
+            142,
+            825,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. A Possibility for Implementing Curiosity and Boredom in Model-Building ¨ Neural Controllers. Meyer, J.A. and Wilson, S.W. (eds) : From Animals to animats, pp. 222–227, 1991. ",
+        "bbox": [
+            173,
+            210,
+            826,
+            252
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. Schulman, F. Wolski, P. Dhariwal, A. Radford, and O. Klimov. Proximal policy optimization algorithms. arXiv:1707.06347, 2017. ",
+        "bbox": [
+            171,
+            263,
+            825,
+            292
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "John Schulman, Sergey Levine, Philipp Moritz, Michael I. Jordan, and Pieter Abbeel. Trust region policy optimization. Arxiv preprint 1502.05477, 2015. ",
+        "bbox": [
+            171,
+            303,
+            823,
+            333
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Silver, Yand, and Li. Lifelong machine learning systems: Beyond learning algorithms. DAAAI Spring Symposium-Technical Report, 2013., 2013. ",
+        "bbox": [
+            171,
+            343,
+            823,
+            372
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Bradly C. Stadie, S. Levine, and P. Abbeel. Incentivizing exploration in reinforcement learning with deep predictive models. arXiv:1507.00814, 2015. ",
+        "bbox": [
+            173,
+            382,
+            821,
+            411
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jan Storck, Sepp Hochreiter, and Jurgen Schmidhuber. Reinforcement driven information acquisi- ¨ tion in non-deterministic environments. Proceedings of the International . . . , 2:159–164, 1995. ",
+        "bbox": [
+            171,
+            421,
+            821,
+            452
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Yi Sun, Faustino Gomez, and Jurgen Schmidhuber. Planning to be surprised: Optimal Bayesian ¨ exploration in dynamic environments. Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 6830 LNAI:41–51, 2011. ISSN 03029743. doi: 10.1007/978-3-642-22887-2 5. ",
+        "bbox": [
+            174,
+            460,
+            825,
+            517
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "H. Tang, R. Houthooft, D. Foote, A. Stooke, X. Chen, Y. Duan, J. Schulman, F. De Turck, and P. Abbeel. exploration: A study of count-based exploration for deep reinforcement learning. arXiv:1611.04717, 2016. ",
+        "bbox": [
+            178,
+            529,
+            823,
+            571
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Taylor and Stone. Transfer learning for reinforcement learning domains: A survey. DAAAI Spring Symposium-Technical Report, 2013., 2009. ",
+        "bbox": [
+            174,
+            582,
+            821,
+            612
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "S. Tessler, C. Givony, T. Zahavy, D.J. Mankowitz, and S. Mannor. A deep hierarchical approach to lifelong learning in minecraft. arXiv:1604.07255, 2016. ",
+        "bbox": [
+            173,
+            622,
+            823,
+            651
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Thrun. Is learning the n-th thing any easier than learning the first? NIPS, 1996. ",
+        "bbox": [
+            173,
+            661,
+            694,
+            676
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A. S. Vezhnevets, S. Osindero, T. Schaul, N. Heess, M. Jaderberg, D. Silver, and K. Kavukcuoglu. Feudal networks for hierarchical reinforcement learning. arXiv preprint arXiv:1703.01161, 2017. ",
+        "bbox": [
+            173,
+            688,
+            826,
+            717
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. X. Wang, Z. Kurth-Nelson, D. Tirumala, H. Soyer, J. Z. Leibo, R. Munos, C. Blundell, D. Kumaran, and M. Botvinick. Learning to reinforcement learn. arXiv:1611.05763, 2016. ",
+        "bbox": [
+            173,
+            727,
+            823,
+            756
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Wiering and Schmidhuber. Hq-learning. Adaptive Behavior, 1997. ",
+        "bbox": [
+            174,
+            766,
+            611,
+            781
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist reinforcement learning. Machine Learning 8, 3-4 (1992), 229256, 1992. ",
+        "bbox": [
+            173,
+            792,
+            823,
+            820
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "7 APPENDIX A: MAML REWARDS VS NUMBER OF GRADIENT STEPS ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            848,
+            767,
+            866
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "In the experiment, only 1-step of gradient descent is done in the MAML variants. However, we have explored doing multiple steps of PPO SGD for each task. Example screenshots of multiple gradient update during training are shown below. ",
+        "bbox": [
+            174,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/1105976585ce84a1dd34b7fba623d734a12ee79bc5f26ade1c0e47e6bcdd6778.jpg",
+        "image_caption": [
+            "Figure 8: MAML on the right and E-MAML on the left. A look at the number of gradient steps at test time vs reward on the Krazy World environment. Both MAML and E-MAML do not typically benefit from seeing more than one gradient step at test time. Hence, we only perform one gradient step at test time for the experiments in this paper. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            200,
+            101,
+            799,
+            458
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "8 APPENDIX B: E-MAML EXPLORATION AS A CHOICE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            556,
+            656,
+            574
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The path-integral formulation of the expected reward in E-MAML is ",
+        "bbox": [
+            174,
+            588,
+            625,
+            604
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72ec2761e09823d14a43ab67d9693ed89d77df5e8e6da1a9a2acf48c77513a54.jpg",
+        "text": "$$\n\\mathcal { L } ( \\boldsymbol { \\theta } _ { 0 } ) = - \\int \\int R ( \\tau ) \\cdot \\pi ( a _ { i } | s _ { i } , U ( \\boldsymbol { \\theta } _ { 0 } , R ( \\bar { \\tau } ) , \\bar { \\tau } \\sim \\pi ( a | \\boldsymbol { \\theta } _ { 0 } ) ) ) \\cdot \\pi ( \\bar { a } _ { i } | \\bar { s } _ { i } , \\boldsymbol { \\theta } _ { 0 } ) \\mathrm { d } \\tau \\mathrm { d } \\bar { \\tau } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            230,
+            611,
+            754,
+            643
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We can make it easier to tell the role of $U$ by re-writing the action probability $\\pi$ and $U$ in type notation where ",
+        "bbox": [
+            173,
+            650,
+            826,
+            679
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/496fac7aa482a9ff8a8e6f00acf8823001cfe7c473575b74a30f6c80fd082855.jpg",
+        "text": "$$\n\\hat { \\pi } ( \\theta ) : \\Rightarrow \\{ ( \\tau ) : \\mathbb { R } ^ { + } \\Rightarrow \\pi ( a _ { t } | s _ { t } , \\theta ) \\} \\quad \\mathrm { a n d } \\quad \\hat { U } ( \\theta _ { 0 } ) : \\Theta \\Rightarrow U \\bigg ( \\theta _ { 0 } , R ( \\tau ) , \\tau \\sim \\pi ( a | \\theta _ { 0 } ) \\bigg ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            683,
+            789,
+            718
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "$\\hat { \\pi }$ returns a function on trajectories $\\tau \\in \\mathcal { T }$ , whereas $\\hat { U }$ takes in two more variables from it’s closure, and returns an updated $\\theta \\in \\Theta$ . Using the Polish notation $@$ applied from-left-to-right, the surrogate loss could be written as ",
+        "bbox": [
+            173,
+            727,
+            826,
+            770
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/be07582050c79195b23cc80b03bf4693f387b10621f6b11ebb7227b0d7151919.jpg",
+        "text": "$$\n\\mathcal { L } ( \\theta _ { 0 } ) = - \\iint _ { \\mathbf { \\Omega } } R ( \\tau ) \\cdot \\Big ( \\hat { \\pi } \\circ \\hat { U } \\Big ) { \\ @ \\theta _ { 0 } \\ @ \\bar { \\tau } \\cdot \\hat { \\pi } \\ @ \\theta _ { 0 } \\ @ \\bar { \\tau } } \\mathrm { d } \\tau \\mathrm { d } \\bar { \\tau } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            773,
+            612,
+            806
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "In this notation, it becomes clear that you could pick any arbitrary function for the inner-update operator $\\hat { U }$ . Under this context, the update operator of choice in E-MAML (and similarly MAML) is an instance from a more general class of exploratory operators $\\mathcal { O }$ : ",
+        "bbox": [
+            173,
+            813,
+            825,
+            858
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d0e5b0ba59032a372c0e54baaa2e8f98357f70d80a4eb48d5befe85984111f91.jpg",
+        "text": "$$\n\\hat { U } _ { \\mathrm { M A M L } } ( \\mathrm {  ~ \\lambda ~ } ) : \\Theta \\Rightarrow \\mathrm { S G D } \\biggl ( \\mathcal { L } _ { \\mathrm { P P O } } , \\tau ( \\pi ( \\mathrm {  ~ \\lambda ~ } ) ) , \\biggr )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            232,
+            864,
+            540,
+            900
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "where the class of operators it belongs to is $\\hat { U } _ { \\mathrm { M A M L } } \\in \\mathcal { O } : \\{ ( \\Theta ) : \\Rightarrow \\Theta \\}$ ",
+        "bbox": [
+            174,
+            907,
+            640,
+            925
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "So what is this PPO/VPG update operator? One could argue that $U _ { \\mathrm { M A M L } }$ is a “reward-maximizing” exploration strategy. The reward collected during the exploration phase is used to compute the gradient direction for $\\theta _ { 0 }$ , which is in-turn used to update $\\theta _ { 0 } \\to \\theta$ . ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Then it becomes immediately obvious there are a few other operators that could also be plugged in: ",
+        "bbox": [
+            176,
+            152,
+            823,
+            167
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "• random exploration on a single task, where $\\theta$ is perturbed randomly.   \n• natural gradient on a single task, where such perturbation is scaled with the inverse fisher information.   \n• perpendicular to gradient: Another extreme is to update the initial parameter $\\theta _ { 0 }$ perpendicular to the gradient direction.   \n• $\\varepsilon$ -greedy: A middle ground between these extremes is a $\\varepsilon$ -greedy exploration strategy, where for $\\varepsilon$ of the time the per-task exploration is done randomly, whereas for the rest of the time $( 1 - \\varepsilon )$ the gradient direction is picked.   \nMeta-learned Exploratory Operator where the inner-update operator $U$ is learned to optimality to a specific class of tasks. See Schmidhuber (2006; 1987). Distraction-free Learning where the sign of the explorative log probability is flipped. This should discourage exploratory behavior. This could be useful in a life-long learning agent during test time, where exploration is extremely costly. ",
+        "bbox": [
+            215,
+            179,
+            825,
+            385
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We are planning on exploring these directions in the future. ",
+        "bbox": [
+            173,
+            397,
+            562,
+            411
+        ],
+        "page_idx": 13
+    }
+]