Add files using upload-large-folder tool

parse/train/BJgcwh4FwS/BJgcwh4FwS.md

@@ -0,0 +1,467 @@
+# NEURAL MAXIMUM COMMON SUBGRAPH DETECTION WITH GUIDED SUBGRAPH EXTRACTION
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Maximum Common Subgraph (MCS) is defined as the largest subgraph that is commonly present in both graphs of a graph pair. Exact MCS detection is NPhard, and its state-of-the-art exact solver based on heuristic search is slow in practice without any time complexity guarantee. Given the huge importance of this task yet the lack of fast solver, we propose an efficient MCS detection algorithm, NEURALMCS, consisting of a novel neural network model that learns the nodenode correspondence from the ground-truth MCS result, and a subgraph extraction procedure that uses the neural network output as guidance for final MCS prediction. The whole model guarantees polynomial time complexity with respect to the number of the nodes of the larger of the two input graphs. Experiments on four real graph datasets show that the proposed model is $3 1 . 7 8 \times$ faster than the exact solver while achieving near-perfect accuracy in MCS detection.
+
+# 1 INTRODUCTION
+
+Graph data are ubiquitous. Due to its flexible and expressive nature, graphs have been used to store data of various domains. In computational biology, atomic networks can represent molecular compounds. In software analysis, program dependence graphs can describe the data and control dependencies. In social science, social networks can represent community structures. Because of graphs’ unique ability to capture these data, algorithms tackling novel tasks on graphs across different domains have been gaining increased interest in the representation learning community.
+
+Graph matching, in particular, is a recently popular task with new approaches such as Zanfir & Sminchisescu (2018), Bai et al. (2019a), and Li et al. (2019). These methods either produce a score indicating how much and/or how well two graphs match or a graph alignment indicating how and where two graphs match. The latter case is a far more difficult task than the former one. Current methods perform a special case of graph alignment, namely image matching, where the two input graphs are of spatial structures (ex. pixel grids, object orientation, etc.) To account for more general graphs, we extract the Maximum Common Subgraph (MCS) (Bunke & Shearer, 1998), a widely used metric for graph alignment, and perform matching on the extracted subgraphs.
+
+MCS is a very useful metric to match two graphs in real-world applications. For example, in drug discovery, identifying compounds sharing similar substructures which tend to share similarity properties can dramatically reduce the amount of molecules that need to be manually tested (Ehrlich & Rarey, 2011). In addition to molecular science, MCS also has application values in malware detection (Park et al., 2013), pattern recognition (Solnon et al., 2015), computer-aided circuit design (Djoko et al., 1997; Li et al., 2012), etc. Unfortunately, MCS is NP-hard and, to the best of our knowledge, no existing algorithms tackle this problem from a purely machine learning approach.
+
+We are among the first to tackle graph matching defined by MCS. This is more challenging than image matching or graph similarity computation, because MCS requires the extraction of the largest connected subgraph that is commonly present in both input graphs. This implies that the two extracted subgraphs must not only be contained in both graphs but also be isomorphic to each other. To capture the MCS definition, our proposed model, NEURALMCS, fundamentally changes the way that the representations are learned. Instead of computing similarity all in one step, we introduce an iterative procedure to match nodes one at a time. By selecting nodes successively, we ensure the extracted subgraphs are connected. We utilize subgraph embeddings to perform a stopping condition check, dealing with subgraph isomorphism and ending the procedure when the connected subgraphs are the largest. By performing this iterative procedure, we both better ensure the isomorphism of the extracted subgraph as well as capture the recurrent relationship between matching pairs of nodes.
+
+![](images/3b709cc607db6fa1ce65918001d29e7e9068fc14b7d5f9e275dd8306ebf5d953.jpg)  
+Figure 1: For a graph pair $( \mathcal { G } _ { 1 } , \mathcal { G } _ { 2 } )$ , previous works (Bai et al., $2 0 1 9 \mathrm { a }$ ; 2018; Li et al., 2019) focus on predicting their graph-graph similarity score. In this work, we aim to find the Maximum Common Subgraph (MCS) (circled in red), which requires fine-grained node-node correspondence prediction. It is more useful both due to the application value as described in Section 1 and because of the interpretable similarity result indicated by the node-node mapping. Node text indicates node labels.
+
+We experimentally verify NEURALMCS on four real graph datasets. and show that NEURALMCS can achieve $4 8 . 1 \times$ runtime gain over state-of-the-art exact MCS computation algorithm MCSPLIT (McCreesh et al., 2017), and is much more accurate than all the baseline approximate approaches to graph matching.
+
+# 2 PROBLEM DEFINITION AND PRELIMINARIES
+
+# 2.1 PROBLEM DEFINITION
+
+We denote a graph as $\mathcal { G } = ( V , E )$ with node set $V$ and edge set $E$ . We define as an induced subgraph as $\boldsymbol { \mathcal { G } } ^ { \prime } = ( \boldsymbol { V } ^ { \prime } , \boldsymbol { E } ^ { \prime } )$ where $V ^ { ' } \subseteq V$ and $E ^ { ' } \subseteq E$ and $E ^ { ' }$ preserves all edges between nodes in $V ^ { ' }$ in the original graph $\mathcal { G }$ . In other words, for two nodes in $V ^ { ' }$ , if there is an edge between them in $\mathcal { G }$ , the induced subgraph must also contain the edge. In the rest of the paper, we use the term “subgraph” to refer to “induced subgraph”.
+
+In this work, our goal is to detect the Maximum Common Subgraph (MCS) for an input graph pair $( \mathcal { G } _ { 1 } , \mathcal { G } _ { 2 } )$ . In general, MCS refers to the largest (induced) subgraph that is common to both graphs. In this paper, we make the following qualifications:
+
+• Labeled graph. The nodes of $\mathcal { G } _ { 1 }$ and $\mathcal { G } _ { 2 }$ are labeled, and nodes of different labels cannot be matched.   
+• Connected subgraph. We require the detected subgraph to be connected, which is a common qualification consistent with McCreesh et al. (2017).
+
+Our goal is to detect the MCS for an input graph pair $\mathcal { G } _ { 1 } , \mathcal { G } _ { 2 }$ . We adopt the state-of-the-art exact solver, MCSPLIT (McCreesh et al., 2017), to provide ground-truth MCS results for a set of training graph pairs. Specifically, MCSPLIT provides not only the nodes that are included in the MCS in both graphs, but also the node-node correspondence in the MCS, as illustrated in Figure 1.
+
+# 2.2 NODE REPRESENTATION LEARNING
+
+Among various node embedding methods, GRAPH MATCHING NETWORKS (GMN) (Li et al., 2019) are recent models designed for graph similarity computation. GMN is based on GRAPH CONVOLUTIONAL NETWORKS (GCN) (Kipf & Welling, 2016), but in addition to message passing within a graph (intra-graph), GMN explicitly handles inter-graph information passing between the two input graphs.
+
+First, GMN performs explicit cross-graph communication on node embeddings denoted as $\mathbf { \Omega } _ { h } ( l )$ where initial node features have $l = 0$ . More specifically, cross-graph communication is achieved through the following attention based mechanism: $\begin{array} { r } { a _ { j \to i } = \frac { \exp ( \cos ( \pmb { h } _ { i } ^ { ( l ) } , \pmb { h } _ { j } ^ { ( l ) } ) } { \sum _ { j ^ { \prime } } \exp ( \cos ( \pmb { h } _ { i } ^ { ( l ) } , \pmb { h } _ { j ^ { \prime } } ^ { ( l ) } ) } } \end{array}$ Next, a softmax function is applied to the cosine similarity between two node embeddings which makes sure similar node pairs across graphs receive greater attention. This weight is then multiplied with the difference between cross-graph node embeddings to allow all node pairs in the two graphs to communicate with each other. Finally each node embedding resulted from inter-graph message passing is concatenated with embedding from intra-graph neighborhood aggregation and placed through a MLP or a GRU core to complete a single layer update of a $h _ { i }$ .
+
+# 3 THE PROPOSED APPROACH: NEURALMCS
+
+Our proposed approach, NEURALMCS, relies on the learning capacity of the embedding model to generate a good matching matrix for each input graph pair, encoding the likelihood of each nodenode pair being included in the MCS and matched to each other. Therefore, the training process aims to learn a matching matrix for each graph pair that is as close to the ground-truth node-node correspondence (as illustrated in Figure 1) as possible.
+
+However, we suppose that a good matching matrix by itself is not enough for an accurate prediction of the MCS, mainly due to the fact that MCS by definition requires the two extracted subgraphs must be isomorphic to each other and both subgraphs must also be connected (see Section 2.1). To satisfy these two requirements, we propose a novel GUIDED SUBGRAPH EXTRACTION (GSE) process that iteratively performs a guided search procedure to enlarge both extracted subgraphs using the matching matrix as guidance. The rest of the section details our proposed approach.
+
+# 3.1 MATCHING MATRIX GENERATION
+
+Our task fundamentally requires the matching between two graphs. Therefore, the ideal node embeddings should receive information from the nodes of both graphs. Thus, we adopt the state-of-theart node embedding model, GRAPH MATCHING NETWORKS (GMN), as described in Section 2.2. Specifically, we stack $L$ GMN layers on the input node representations to allow inter-graph message passing at multiple scales for sufficient interaction of the two graphs. We denote the final node representations as U1 ∈ R|V1|×D(L) and U2 ∈ R|V2|×D(L) .
+
+To match nodes from the input graphs, we compute the likelihood of matching each node in $\mathcal { G } _ { 1 }$ to each node in $\mathcal { G } _ { 2 }$ . This likelihood indicates which node pair is most likely to be in the MCS, and should account for cases where some nodes in $\mathcal { G } _ { 1 }$ do not match any nodes in $\mathcal { G } _ { 2 }$ (and vice-versa). We naturally encode these likelihoods into a matching matrix, $Y \in [ 0 , 1 ] ^ { | \mathcal { G } _ { 1 } | \times | \mathcal { G } _ { 2 } | }$ .
+
+To compute $\mathbf { Y }$ , one can simply calculate the dot product between the node embeddings, $U _ { 1 } \pmb { U } _ { 2 } ^ { \top }$ . However, this resulting matrix is simply the similarity score between each pair of nodes in the two graphs, which is in the range of $( - \operatorname { i n f } , + \operatorname { i n f } )$ and requires further processing to reflect the probability of the node pair matched and being included in the MCS.
+
+As this matrix encode the general similarity between nodes, we denote it as the similarity matrix, $\boldsymbol { X }$ , and further normalize it to obtain $\mathbf { Y }$ . Specifically, we perform the following transformations.
+
+To find the likelihood of each node in one graph matching each node in the other graph, we apply column-wise and row-wise normalization on $\boldsymbol { X }$ .
+
+$$
+\tilde { p } _ { c o l n } ( i , j ) = \frac { e ^ { X _ { i j } } } { \sum _ { k } e ^ { X _ { i k } } } , ~ \tilde { p } _ { r o w } ( i , j ) = \frac { e ^ { X _ { i j } } } { \sum _ { k } e ^ { X _ { k j } } }
+$$
+
+To allow for some nodes to go unmatched, we multiply these likelihoods by a value encoding the overall matching score of a node in one graph to nodes in the other graph.
+
+$$
+p _ { c o l n } ( i , j ) = \sigma ( \frac { \sum _ { j } X _ { i j } } { | V _ { 2 } | } ) \cdot \tilde { p } _ { c o l n } ( i , j ) , ~ p _ { r o w } ( i , j ) = \sigma ( \frac { \sum _ { i } X _ { i j } } { | V _ { 1 } | } ) \cdot \tilde { p } _ { r o w } ( i , j )
+$$
+
+We consider both row-wise and column-wise normalization by taking the average of both scores, $\begin{array} { r } { \tilde { p } ( i , j ) = \frac { p _ { c o l n } ( i , j ) + p _ { r o w } ( i , j ) } { 2 } } \end{array}$ , and, to ensure we only select nodes with the same labels, we mask out node pairs with different labels to form $\mathbf { Y }$ .
+
+# 3.2 LEARNING OF NEURALMCS
+
+Although there exist multiple points where we can apply our loss function (before, during, or after GSE), we found that applying binary cross entropy loss as early as possible allows for GMN to receive a better learning signal. For this reason, our loss function acts directly on the matching matrix.
+
+![](images/4a4ace361aa52456241d185c40ca4da878d5d2e7f06d58ba7be373377ab7e23a.jpg)  
+Figure 2: A detailed illustration of NEURALMCS using the example graph pair in Figure 1. For the input graph pair $( \mathcal { G } _ { 1 } , \mathcal { G } _ { 2 } )$ , the NEURALMCS first generates a matching matrix encoding the likelihood of each pair of node being matched ((a) and (b)). The GUIDED SUBGRAPH EXTRACTION (GSE) process uses the matching matrix as follows: NEURALMCS selects the initial pair to be included in the predicted MCS, node 2 in $\mathcal { G } _ { 1 }$ and node 6 in $\mathcal { G } _ { 2 }$ ((b) and (c)). Next, NEURALMCS sets its search frontier as the neighbors of the selected nodes, circled in dashed blue lines. By selecting the pair with the largest matching score which still preserves subgraph isomorphism, node 3 in $\mathcal { G } _ { 1 }$ and node 5 in $\mathcal { G } _ { 2 }$ , the extracted subgraphs in both graphs grow to size 2 ((d) and (e)). The procedure continues until a stopping condition is reached, which is detailed in Section 3.3.
+
+Specifically, we design the following loss function to train the model $\begin{array} { r } { L ( \pmb { Y } ) = - \sum _ { i } \sum _ { j } \frac { I _ { i j } l o g ( Y _ { i j } ) } { | V _ { 1 } | \cdot | V _ { 2 } | } } \end{array}$ where $Y _ { i j }$ denotes our predicted matching matrix and $I _ { i j }$ denote an indicator value of whether the node $i$ matches node $j$ in the ground truth.
+
+Since for a given graph pair, there can be multiple correct MCSs of equal size, we also employ multiple choice learning (Guzman-Rivera et al., 2012; Li et al., 2018). This is done by ensembling various copies of the model and propagating the loss function only through the copy which achieves the lowest loss, as shown by the following: $L = m i n _ { \mathbf { Y } \in \mathcal { Y } } ( L ( \mathbf { Y } ) )$ .
+
+# 3.3 GUIDED SUBGRAPH EXTRACTION (GSE)
+
+Given a matching matrix $\mathbf { Y }$ encoding the matching likelihood for all node pairs between $\mathcal { G } _ { 1 }$ and $\mathcal { G } _ { 2 }$ , we propose the following GUIDED SUBGRAPH EXTRACTION (GSE) process. It starts by finding the most likely pair, and iteratively expands the extracted subgraphs by selecting one more node pair at a time. The procedure stops once the addition of any additional pair would lead to non-isomorphic subgraphs. In summary, the proposed algorithm is shown in Algorithm 1. A detailed illustration using an example pair from Figure 1 is shown in Figure 2.
+
+The GSE algorithm internally maintains a binary assignment matrix $_ { \mathbf { T } }$ which will be the final output indicating the predicted MCS, and a masking matrix $M$ , which is used to mask and select entries of the matching matrix $\mathbf { Y }$ . Both matrices are of the same dimension as $\mathbf { Y }$ . $\mathbf { T }$ is initialized to all zeros, indicating no selected nodes, i.e. extracted subgraphs are zero-size. $M$ is initialized to all ones, since NEURALMCS may select any node pair for its initial subgraph.
+
+To select the most likely node matching, the algorithm decides which pair of nodes should be selected (see Section 3.3.1 for details) by order of their matching scores. This involves checking whether the selection of the pair would result in two isomorphic subgraphs or not. Only if so, the algorithm would select the pair (circled in red in Figure 1) and include it in the predicted MCS by updating $T _ { i ^ { \dag } , j ^ { \dag } }$ to be 1. Once a new node pair is included, GSE updates the mask $M$ to reflect the
+
+# Algorithm 1 GUIDED SUBGRAPH EXTRACTION (GSE)
+
+1: Input: $\left\{ A _ { 1 } , A _ { 2 } \right\}$ , $\mathbf { Y }$ , node embeddings $\{ U _ { 1 } , U _ { 2 } \}$ , .   
+2: Output: Assignment matrix $_ { \mathbf { T } }$ .   
+3: Initialize $T \gets 0 * Y$ . \\ initialize to all zeros   
+4: Initialize $M \gets 1 * Y$ . \\ initialize to all ones   
+5: Initialize update True   
+6: while update $=$ True   
+7: $\mathbf { I } $ sorted indices by highest to lowest value of elements in $\mathbf { M } \odot \mathbf { Y }$   
+8: for node pair $( { \bf i } ^ { \dag } , j ^ { \dag } ) { \bf \bar { \Lambda } } = { \bf I }$   
+9: update $\because  \mathtt { F a l s e }$   
+10: Compute subgraph embeddings $w _ { 1 } , w _ { 2 }$ via Equation 4.   
+11: if $| | \boldsymbol { \bar { w } } _ { 1 } - \boldsymbol { w } _ { 2 } | | _ { 2 } \stackrel { - } { \le } \epsilon \stackrel { \cdot } { \backslash } \backslash$ subgraph isormorphism check   
+12: Select the found pair $( i ^ { \dagger } , j ^ { \dagger } )$ by updating $T _ { i ^ { \dagger } , j ^ { \dagger } } \gets 1$ .   
+13: Expand the search frontier by updating the mask $M$ via Equation 6.   
+14: update $\gets$ True   
+15: break
+
+search frontier for the next iteration (see Section 3.3.2 for details) and proceeds to the next iteration. Since the MCS by definiton requires the extracted subgraphs to be connected graphs, we define the search frontier as the first-order neighboring nodes of the current selected nodes. This guarantees the final predicted MCS satisfies the connectivity constraint described in Section 1.
+
+# 3.3.1 SUBGRAPH ISOMORPHISM CHECK
+
+To decide whether node pair $( i ^ { \dagger } , j ^ { \dagger } )$ from the search frontier can be selected or not, we check if the inclusion of node $i ^ { \dagger }$ in $\mathcal { G } _ { 1 }$ and $j ^ { \dagger }$ in $\mathcal { G } _ { 2 }$ would result in two isomorphic subgraphs. To do this, we compute the two subgraph-level embeddings, ${ \pmb w } _ { 1 }$ and ${ \pmb w } _ { 2 }$ and check if their Euclidean distance is greater than a hyperparameter threshold $\epsilon$ . A more detailed discussion can be found in Appendix H and I.
+
+Computing the subgraph-level embeddings, however, involves more than a simple aggregation of node embeddings from $U _ { 1 }$ or $U _ { 2 }$ . This is because for subgraph isomorphism check, we are only concerned with nodes included in the subgraph. The nodes outside the selected subgraph should not affect the nodes inside. However, during node embedding generation, both intra- and inter-graph message passing are performed, resulting in $U _ { 1 }$ and $U _ { 2 }$ containing unwanted information.
+
+Inspired by the Weisfeiler-Lehman (WL) algorithm for approximate graph isomorphism test (Shervashidze et al., 2011), as well as the connection between the WL algorithm and the GCNs, we recompute the node embeddings by only aggregating neighboring nodes that are included in the current predicted MCS indicated by $\mathbf { T }$ :
+
+$$
+\begin{array} { r } { U _ { 1 } ^ { ( k + 1 ) } = A _ { 1 } ( \pmb { v _ { 1 } } \odot \pmb { U } _ { 1 } ^ { ( k ) } ) , } \\ { U _ { 2 } ^ { ( k + 1 ) } = A _ { 2 } ( \pmb { v _ { 2 } } \odot \pmb { U } _ { 2 } ^ { ( k ) } ) , } \end{array}
+$$
+
+where $\pmb { A }$ denotes the adjacency matrix, ${ \pmb v } _ { 1 } \in \{ 0 , 1 \} ^ { | V _ { 1 } | }$ and $v _ { 2 } \in \{ 0 , 1 \} ^ { | V _ { 2 } | }$ are defined as the row and column summation1 of $\mathbf { T }$ , i.e. $\begin{array} { r } { v _ { 1 i } = \sum _ { j = 1 } ^ { | V _ { 2 } | } T _ { i , j } , v _ { 2 j } = \sum _ { i = 1 } ^ { | V _ { 1 } | } T _ { i , j } } \end{array}$ , followed by setting $v _ { 1 i ^ { \dagger } }$ and $v _ { 2 j ^ { \dagger } }$ to 1, and $_ { v \odot U }$ denotes element-wise multiplication, i.e. $( v \odot U ) _ { i , j } = v _ { i } U _ { i , j }$ . For each graph, this performs message passing between nodes in the extracted subgraph plus the node $i ^ { \dagger }$ (for $\mathcal { G } _ { 1 }$ ) or $j ^ { \dagger }$ (for $\mathcal { G } _ { 2 }$ ). All the edges between these nodes are involved via the adjacency matrices $\pmb { A } _ { 1 }$ and $A _ { 2 }$ , ensuring the subgraph is an induced subgraph required by the MCS definition as mentioned in Section 2.1.
+
+The above updates are performed for $K$ times to yield the final subgraph node embeddings denoted as U (K) ∈ R|V1|×D(K) and $U _ { 2 } ^ { ( K ) } \ \in \ \mathbb { R } ^ { | V _ { 2 } | \times D ^ { \hat { ( } K ) } }$ . We finally compute the two subgraph-level embeddings whose Euclidean distance is computed for apporximate subgraph isomorphism test:
+
+$$
+\begin{array} { r } { \pmb { w } _ { 1 } = \sum _ { i = 1 } ^ { | V _ { 1 } | } ( \pmb { v } _ { 1 } \odot \pmb { U } _ { 1 i , : } ^ { ( K ) } ) , } \\ { \pmb { w } _ { 2 } = \sum _ { j = 1 } ^ { | V _ { 2 } | } ( \pmb { v } _ { 2 } \odot \pmb { U } _ { 2 j , : } ^ { ( K ) } ) , } \end{array}
+$$
+
+# 3.3.2 SEARCH FRONTIER EXPANSION
+
+As the search process finds more node pairs, the mask $M$ reflects the search frontier, i.e. the candidate node pairs for the next iteration to select from. Specifically, $M _ { i , j }$ denotes whether the node pair $( i , j )$ should be a candidate pair, and the sorting for node pairs is performed on $M \odot Y$ .
+
+Once node pair $( i ^ { \dagger } , j ^ { \dagger } )$ is selected by passing the check described in Section 3.3.1, GSE updates the search frontier by first obtaining two binary vectors indicating the neighbors of the selected nodes. Since each row of the adjacency matrix indicates the neighbors of the nodes of a particular graph, and we need to include neighbors of all the selected nodes, we first perform the following aggregation of rows of the adjacency matrix:
+
+$$
+\begin{array} { r } { \pmb { p } _ { 1 } = ( \sum _ { i = 1 } ^ { | V _ { 1 } | } \pmb { v } _ { 1 } \odot \pmb { A } _ { 1 i , : } ) \odot ( 1 - \pmb { v } _ { 1 } ) , } \\ { \pmb { p } _ { 2 } = ( \sum _ { j = 1 } ^ { | V _ { 2 } | } \pmb { v } _ { 2 } \odot \pmb { A } _ { 2 j , : } ) \odot ( 1 - \pmb { v } _ { 2 } ) . } \end{array}
+$$
+
+The $( 1 - v )$ term is for excluding the nodes that are already selected, which is key for ensuring that the next step does not select nodes that are already selected. This further guarantees that the final $_ { \mathbf { T } }$ matrix is an assignment matrix as required by Equation 3.
+
+To obtain a binary indicator vector for the neighbors of selected nodes, we apply an element-wise indicator function, checking whether each entry of $\pmb { p } _ { 1 }$ and $\mathbf { \mathit { p } } _ { 2 }$ is greater than zero, yielding $\pmb q _ { 1 } ~ \in$ $\{ 0 , 1 \} ^ { | V _ { 1 } | }$ and $\pmb { q } _ { 2 } \in \{ 0 , 1 \} ^ { | V _ { 2 } | }$ . Then we can obtain the updated mask $M$ via
+
+$$
+{ \cal M } = q _ { 1 } \otimes q _ { 2 } ,
+$$
+
+where $\otimes$ denotes the dyadic product of two vectors. This allows the selection to choose from the pairs formed by the nodes indicated by $\pmb q _ { 1 }$ and $\pmb { q } _ { 2 }$ .
+
+# 3.4 OVERALL TIME COMPLEXITY
+
+Each GMN layer involves the message passing for all node-node pairs, whose time complexity is quadratic with respect to the number of nodes. The matching matrix computation computes the dot product for all node-node pairs. The GSE process selects one node pair each time, and expands the search frontier by reaching to neighbors of selected nodes. Thus, GSE in the worst case reaches out to all nodes of the smaller of the two input graphs, and each GSE step involves a quadratic mask computation. Therefore, NEURALMCS runs in ${ \cal \bar { O } } ( s * | V _ { 1 } | * | V _ { 2 } | * l o g ( | V _ { 1 } | * | V _ { 2 } | ) )$ time, where $s$ is the size of the predicted MCS, which in the worst case is $\operatorname* { m i n } ( | V _ { 1 } | , | V _ { 2 } | )$ .
+
+# 4 EXPERIMENTS
+
+We evaluate NEURALMCS on its accuracy and efficiency against the state-of-the-art exact MCS solver, MCSPLIT (McCreesh et al., 2017), and current machine learning approaches (Zanfir & Sminchisescu, 2018; Wang et al., $2 0 1 9 \mathrm { a }$ ; Velickovic et al., 2018; Li et al., 2019), on four realworld datasets, AIDS, LINUX, IMDB, and REDDIT from a diverse range of domains. Our baselines incldude the state-of-art MCS computation algorithm, MCSPLIT (McCreesh et al., 2017), IMAGEGMN (Zanfir & Sminchisescu, 2018), IMAGE-PCA (Wang et al., 2019a), BASIC-GAT (Velickovic et al., 2018), and BASIC-GMN (Li et al., 2019). Appendix A and B give more details.
+
+# 4.1 EVALUATION METRICS
+
+For accuracy, we evaluate an exact and a soft metric:
+
+$$
+{ \mathrm { E x a c t ~ } } \% = { \frac { \sum _ { i } ^ { N } C ( S _ { i 1 } , S _ { i 2 } ) \cdot \mathbf { 1 } _ { ( \left| S _ { i 1 } \right| = \left| { \mathrm { M C S } } _ { i } \right| ) } } { N } }
+$$
+
+$$
+\mathrm { S o f t } ~ \% = \frac { \sum _ { i } ^ { N } C ( S _ { i 1 } , S _ { i 2 } ) \cdot \frac { | S _ { i 1 } | + | S _ { i 2 } | } { 2 | \mathrm { M C S } _ { i } | } } { N }
+$$
+
+where $N$ is the number of graph pairs in the testing set; $S _ { i 1 }$ and $S _ { i 2 }$ are the subgraphs extracted from the first and second graph, respectively; $C ( \cdot , \cdot )$ is a function that returns 1 if the two input graphs are isomorphic to each other and 0 otherwise; 1 is the indicator function that returns 1 when the condition is true and 0 otherwise; $| \mathrm { M C S } _ { i } |$ is the true MCS size. For efficiency, we evaluate the average running time across graph pairs.
+
+# 4.2 RESULTS
+
+We see that in terms of accuracy, NEURALMCS improves current methods of subgraph extraction substantially, especially on the AIDS and LINUX datasets, where NEURALMCS performs close to the ground truth solver. For IMDB and REDDIT, the performance is also drastically higher than the baselines. Most interestingly, we find that, when the model does not find the exact ground-truth solution, it still extracts high-quality subgraphs with sizes on average above $90 \%$ of the true MCS size, where all graphs are isomorphic (see Appendix E). The poor performance of computer vision baselines IMAGE-GMN and IMAGE-PCA suggests that the assumptions for image matching do not work for MCS based graph matching very well. Appendix F provides a thorough analysis of the performance boost from each component of the proposed model compared with various alternative designs. Compared against the 2 basic models, we see that both the representation learning scheme and the extraction strategy greatly enhance the performance of the model. The exact accuracy results can be seen in Table 1.
+
+Table 1: Exact $\%$ and Soft $\%$ accuracy metrics across four real graph datasets. All methods have been adapted for the MCS detection task. MCSPLIT is the ground-truth MCS solver labeled with \*.
+
+<table><tr><td rowspan="2">Method</td><td colspan="2">AIDS</td><td colspan="2">LINUX</td><td colspan="2">IMDB</td><td colspan="2">REDDIT</td></tr><tr><td>Exact %</td><td>Soft %</td><td>Exact %</td><td>Soft %</td><td>Exact %</td><td>Soft %</td><td>Exact %</td><td>Soft %</td></tr><tr><td>MCSPLIT *</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>IMAGE-GMN</td><td>0.033</td><td>0.033</td><td>19.790</td><td>19.790</td><td>N/A</td><td>N/A</td><td>20.261</td><td>20.261</td></tr><tr><td>IMAGE-PCA</td><td>0.229</td><td>0.229</td><td>22.693</td><td>22.693</td><td>38.582</td><td>38.582</td><td>33.987</td><td>33.987</td></tr><tr><td>BASIC-GAT</td><td>11.013</td><td>22.199</td><td>41.135</td><td>53.070</td><td>47.462</td><td>51.680</td><td>37.908</td><td>50.196</td></tr><tr><td>BASIC-GMN</td><td>12.488</td><td>19.256</td><td>48.082</td><td>52.590</td><td>55.273</td><td>62.738</td><td>43.137</td><td>51.782</td></tr><tr><td>NEURALMCS</td><td>98.525</td><td>99.626</td><td>99.674</td><td>99.955</td><td>97.235</td><td>99.613</td><td>96.078</td><td>99.562</td></tr></table>
+
+In terms of efficiency, NEURALMCS is $3 1 . 7 8 \times$ faster than the ground-truth solver averaged across the four datasets, while being slightly slower than the baselines.
+
+However, as shown in Table 1, the baseline methods fail to consider the connectivity and subgraph isomorphism constraints during maximum common subgraph extraction resulting in worse accuracy. The exact performance results can be seen in Figure 3.
+
+![](images/790a8630f4ddb566085e971c2976250766d11579abf5d1eee572f4c4d40e99e4.jpg)  
+Figure 3: Running time comparison.
+
+# 4.3 CASE STUDY
+
+The iterative expansion ensures that extracted subgraphs satisfy the connectivity constraint. The representation learning component ensures that we select the correct node at each step. As seen in Figure 4, for the AIDS dataset, the learnable matching matrix helps NEURALMCS select good nodes, and, for the IMDB dataset, the iterative procedure indeed helps our model stop once adding additional nodes would break the isomorphism constraint. More importantly, our model is also able to solve both the subgraph isomorphism and graph matching problems. Additional case studies and analysis can be found in Appendix J.
+
+![](images/aaa70f601959c9cd050159d4b031fda53ec660dd6d3d03cc386bb6b81849390b.jpg)  
+Figure 4: Case study: Three MCS examples from each dataset. AIDS has node labels as node text. For clarity, we draw only two node-node correspondences for each example, represented as dashed lines between nodes in the two graphs.
+
+# 5 RELATED WORK
+
+Graph isomorphism is a classic problem that goes back to at least the early work by Sussenguth (1965) and Corneil & Gotlieb (1970). Recently Babai (2016) shows that graph isomorphism can be solved in quasipolynomial time. However, graph isomorphism is only concerned with whether two graphs are exactly the same or not, which may be too rigid in real-world applications. For example, what if two graphs are not isomorphic? In such scenario, a more useful output can be the similarity (or distance) between them, defined by metrics such as Graph Edit Distance (GED) (Bunke, 1983), Maximum Common Subgraph (MCS) (Bunke & Shearer, 1998; Bunke, 1997).
+
+In this work, we focus on the more challenging task of graph matching, specifically the matching of two graphs defined by the MCS metric. The MCS detection problem is NP-hard, and remain computationally challenging. Existing works use constraint programming (Vismara & Valery, 2008; McCreesh et al., 2016), branch-and-bound (McCreesh et al., 2017; Liu et al., 2019), mathematical programming (Bahiense et al., 2012), reduction to maximum clique detection (Levi, 1973; McCreesh et al., 2016), etc. MCS has many definitions tailored to different graph types and application specifics (McCreesh et al., 2017), and is a domain-agnostic metric to compare graphs in a detailed way, so it has occurred widely in applications such as graph database systems (Yan et al., 2005), cloud computing platforms (Cao et al., 2011), etc.
+
+The term “graph matching” is very general and has been adopted by many recent works: (1) Graph similarity computation (Bai et al., 2019a; Li et al., 2019) aims to output a similarity score for an input graph pair, which can be defined by the MCS metric but less challenging due to the score output. (2) Image matching is a classic task in computer vision with traditional approaches based on quadratic assignment problem solving (Zhou & De la Torre, 2012; Yu et al., 2018) and more recent methods using neural networks (IMAGE-GMN (Zanfir & Sminchisescu, 2018) and IMAGEPCA (Wang et al., 2019a)). (3) The two-graph alignment (Heimann et al., 2018; Xu et al., 2019) problem deals with the alignment of two general structured graph objects. However, the alignment is typically not defined by domain-agnostic metrics such as GED or MCS. There is currently no such methods learning from ground-truth graph pairs to the best of our knowledge.
+
+# 6 CONCLUSION
+
+In this paper, we propose a neural network approach to solve the NP-hard problem, Maximum Common Subgraph (MCS) detection, in an approximate and accurate way. For an input graph pair, our model NEURALMCS computes the likelihood of each pair of nodes being included in the MCS and matched, which is used by the proposed GUIDED SUBGRAPH EXTRACTION (GSE) algorithm to iteratively include more and more nodes in the predicted MCS. The whole model runs in polynomial time complexity, and experimental results on four real graph datasets demonstrate that NEURALMCS is $3 1 . 7 8 \times$ faster than the exact solver whole achieving very good accuracy compared to a series of strong approximate graph matching baseline approaches.
+
+# REFERENCES
+
+Laszl ´ o Babai. Graph isomorphism in quasipolynomial time. In ´ STOC, pp. 684–697. ACM, 2016.
+
+Laura Bahiense, Gordana Manic, Breno Piva, and Cid C De Souza. The maximum common edge ´ subgraph problem: A polyhedral investigation. Discrete Applied Mathematics, 160(18):2523– 2541, 2012.
+
+Yunsheng Bai, Hao Ding, Yizhou Sun, and Wei Wang. Convolutional set matching for graph similarity. NeurIPS Workshop on Relational Representation Learning Workshop, 2018.
+
+Yunsheng Bai, Hao Ding, Song Bian, Ting Chen, Yizhou Sun, and Wei Wang. Simgnn: A neural network approach to fast graph similarity computation. WSDM, 2019a.
+
+Yunsheng Bai, Hao Ding, Yang Qiao, Agustin Marinovic, Ken Gu, Ting Chen, Yizhou Sun, and Wei Wang. Unsupervised inductive whole-graph embedding by preserving graph proximity. IJCAI, 2019b.
+
+Albert-Laszl ´ o Barab ´ asi and R ´ eka Albert. Emergence of scaling in random networks. ´ science, 286 (5439):509–512, 1999.
+
+Horst Bunke. What is the distance between graphs. Bulletin of the EATCS, 20:35–39, 1983.
+
+Horst Bunke. On a relation between graph edit distance and maximum common subgraph. Pattern Recognition Letters, 18(8):689–694, 1997.
+
+Horst Bunke and Kim Shearer. A graph distance metric based on the maximal common subgraph. Pattern recognition letters, 19(3-4):255–259, 1998.
+
+Ning Cao, Zhenyu Yang, Cong Wang, Kui Ren, and Wenjing Lou. Privacy-preserving query over encrypted graph-structured data in cloud computing. In 2011 31st International Conference on Distributed Computing Systems, pp. 393–402. IEEE, 2011.
+
+Derek Gordon Corneil and Calvin C Gotlieb. An efficient algorithm for graph isomorphism. Journal of the ACM (JACM), 17(1):51–64, 1970.
+
+Surnjani Djoko, Diane J. Cook, and Lawrence B. Holder. An empirical study of domain knowledge and its benefits to substructure discovery. TKDE, 9(4):575–586, 1997.
+
+Hans-Christian Ehrlich and Matthias Rarey. Maximum common subgraph isomorphism algorithms and their applications in molecular science: a review. Wiley Interdisciplinary Reviews: Computational Molecular Science, 1(1):68–79, 2011.
+
+Matthias Fey and Jan E. Lenssen. Fast graph representation learning with PyTorch Geometric. In ICLR Workshop on Representation Learning on Graphs and Manifolds, 2019.
+
+Abner Guzman-Rivera, Dhruv Batra, and Pushmeet Kohli. Multiple choice learning: Learning to produce multiple structured outputs. In NeurIPS, pp. 1799–1807, 2012.
+
+Mark Heimann, Haoming Shen, Tara Safavi, and Danai Koutra. Regal: Representation learningbased graph alignment. In CIKM, pp. 117–126. ACM, 2018.
+
+Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. ICLR, 2015.
+
+Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. ICLR, 2016.
+
+Philip A Knight. The sinkhorn–knopp algorithm: convergence and applications. SIAM Journal on Matrix Analysis and Applications, 30(1):261–275, 2008.
+
+Harold W Kuhn. The hungarian method for the assignment problem. Naval research logistics quarterly, 2(1-2):83–97, 1955.
+
+Der-Tsai Lee and Bruce J Schachter. Two algorithms for constructing a delaunay triangulation. International Journal of Computer & Information Sciences, 9(3):219–242, 1980.
+
+Giorgio Levi. A note on the derivation of maximal common subgraphs of two directed or undirected graphs. Calcolo, 9(4):341, 1973.
+
+Wenchao Li, Zach Wasson, and Sanjit A Seshia. Reverse engineering circuits using behavioral pattern mining. In 2012 IEEE international symposium on hardware-oriented security and trust, pp. 83–88. IEEE, 2012.
+
+Yujia Li, Chenjie Gu, Thomas Dullien, Oriol Vinyals, and Pushmeet Kohli. Graph matching networks for learning the similarity of graph structured objects. ICML, 2019.
+
+Zhuwen Li, Qifeng Chen, and Vladlen Koltun. Combinatorial optimization with graph convolutional networks and guided tree search. In NeurIPS, pp. 539–548, 2018.
+
+Yongjiang Liang and Peixiang Zhao. Similarity search in graph databases: A multi-layered indexing approach. In ICDE, pp. 783–794. IEEE, 2017.
+
+Yan-li Liu, Chu-min Li, Hua Jiang, and Kun He. A learning based branch and bound for maximum common subgraph problems. IJCAI, 2019.
+
+Ciaran McCreesh, Samba Ndojh Ndiaye, Patrick Prosser, and Christine Solnon. Clique and constraint models for maximum common (connected) subgraph problems. In International Conference on Principles and Practice of Constraint Programming, pp. 350–368. Springer, 2016.
+
+Ciaran McCreesh, Patrick Prosser, and James Trimble. A partitioning algorithm for maximum common subgraph problems. 2017.
+
+Younghee Park, Douglas S Reeves, and Mark Stamp. Deriving common malware behavior through graph clustering. Computers & Security, 39:419–430, 2013.
+
+Nino Shervashidze, Pascal Schweitzer, Erik Jan van Leeuwen, Kurt Mehlhorn, and Karsten M Borgwardt. Weisfeiler-lehman graph kernels. JMLR, 12(Sep):2539–2561, 2011.
+
+Christine Solnon, Guillaume Damiand, Colin De La Higuera, and Jean-Christophe Janodet. On the complexity of submap isomorphism and maximum common submap problems. Pattern Recognition, 48(2):302–316, 2015.
+
+Edward H Sussenguth. A graph-theoretic algorithm for matching chemical structures. Journal of Chemical Documentation, 5(1):36–43, 1965.
+
+Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. ICLR, 2018.
+
+Philippe Vismara and Benoˆıt Valery. Finding maximum common connected subgraphs using clique detection or constraint satisfaction algorithms. In International Conference on Modelling, Computation and Optimization in Information Systems and Management Sciences, pp. 358–368. Springer, 2008.
+
+Runzhong Wang, Junchi Yan, and Xiaokang Yang. Learning combinatorial embedding networks for deep graph matching. ICCV, 2019a.
+
+Xiaoli Wang, Xiaofeng Ding, Anthony KH Tung, Shanshan Ying, and Hai Jin. An efficient graph indexing method. In ICDE, pp. 210–221. IEEE, 2012.
+
+Yue Wang and Justin M Solomon. Deep closest point: Learning representations for point cloud registration. ICCV, 2019.
+
+Yue Wang, Yongbin Sun, Ziwei Liu, Sanjay E Sarma, Michael M Bronstein, and Justin M Solomon. Dynamic graph cnn for learning on point clouds. ACM Transactions on Graphics (TOG), 38(5): 146, 2019b.
+
+Hongteng Xu, Dixin Luo, Hongyuan Zha, and Lawrence Carin. Gromov-wasserstein learning for graph matching and node embedding. ICML, 2019.
+
+Xifeng Yan, Philip S Yu, and Jiawei Han. Substructure similarity search in graph databases. In SIGMOD, pp. 766–777. ACM, 2005.
+
+Pinar Yanardag and SVN Vishwanathan. Deep graph kernels. In SIGKDD, pp. 1365–1374. ACM, 2015.
+
+Tianshu Yu, Junchi Yan, Yilin Wang, Wei Liu, et al. Generalizing graph matching beyond quadratic assignment model. In NeurIPS, pp. 853–863, 2018.
+
+Andrei Zanfir and Cristian Sminchisescu. Deep learning of graph matching. In CVPR, pp. 2684– 2693, 2018.
+
+Zhiping Zeng, Anthony KH Tung, Jianyong Wang, Jianhua Feng, and Lizhu Zhou. Comparing stars: On approximating graph edit distance. PVLDB, 2(1):25–36, 2009.
+
+Xinyi Zhang and Lihui Chen. Capsule graph neural network. ICLR, 2019.
+
+Xiang Zhao, Chuan Xiao, Xuemin Lin, Qing Liu, and Wenjie Zhang. A partition-based approach to structure similarity search. PVLDB, 7(3):169–180, 2013.
+
+Weiguo Zheng, Lei Zou, Xiang Lian, Dong Wang, and Dongyan Zhao. Graph similarity search with edit distance constraint in large graph databases. In CIKM, pp. 1595–1600. ACM, 2013.
+
+Feng Zhou and Fernando De la Torre. Factorized graph matching. In CVPR, pp. 127–134. IEEE, 2012.
+
+# A DATASET DESCRIPTION
+
+We run experiments on 4 diverse different real world datasets coming from the chemical, programming language, and social network domains. For each dataset, we split the pairs into training, validation, and testing sets in the ratio of 6:2:2 such that none of the training, validation, or testing sets share any common graphs. For each dataset, we either one-hot encode node labels, if the dataset has node labels, or provide the same initial encoding, if the dataset does not have node labels. The code and the datasets have been published to this anonymous link: https://github.com/openpublicforpapers/NeuralMCS.
+
+# A.1 AIDS
+
+AIDS is a dataset of antivirus screen chemical compounds, coming from the Developmental Therapeutics Program at $\mathrm { N C I } / \mathrm { N I H } ^ { 2 }$ . The AIDS dataset has been used by various works in graph matching (Zeng et al., 2009; Wang et al., 2012; Zheng et al., 2013; Zhao et al., 2013; Liang & Zhao, 2017; Bai et al., 2019a). These graphs consist of labeled nodes and unlabeled edges, where nodes represent chemical elements (ex. Carbon, Nitrogen, Chlorine, and etc.) and edges represent bonds between atoms. There are a total of 700 graphs, from which we sample 29610 graph pairs. The average graph size is 8.664 with the largest graph having 10 nodes.
+
+# A.2 LINUX
+
+LINUX is a dataset of program dependence graphs (PDG) describing individual functions generated from the Linux kernel (Wang et al., 2012). These graphs consist of unlabeled nodes and unlabeled edges, where nodes represent statements and edges represent control flow between statements. There are a total of 1000 graphs, from which we sample 60114 graph pairs. The average graph size is 7.591 and the largest graphs have 10 nodes.
+
+# A.3 IMDB
+
+IMDB is a dataset of ego-networks of movie actors/actresses from the IMDB website (Yanardag & Vishwanathan, 2015). This dataset has been used by various works in graph classification (Zhang & Chen, 2019; Bai et al., 2019b). These graphs consist of unlabeled nodes and unlabeled edges, where nodes represent actors/actresses and edges represent whether they have had collaborations. There are a total of 1500 graphs, from which we sample 135702 graph pairs. The average graph size is 12.981 and the largest graphs have 89 nodes.
+
+# A.4 REDDIT
+
+REDDIT is a dataset of online dicussion networks from the Reddit online discussion website (Yanardag & Vishwanathan, 2015). These graphs consist of unlabeled nodes and unlabeled edges, where nodes represent users and edges represent whether users have responded to eachother’s comments. There are a total of 7112 graphs, from which we sample 3556 pairs. The average graph size is 11.8 nodes and the largest graph has 16 nodes.
+
+# B BASELINES
+
+We evaluate NEURALMCS against the state-of-the-art solver, MCSPLIT, which uses heuristics and the branch and bound algorithm to achieve efficient computation for MCS. While the fastest among exact solvers, this method still has, in the worst case, exponential time complexity (McCreesh et al., 2017). For this reason, in practice, its running time is much slower than the other approximate baselines. However, we still use MCSPLIT to generate ground-truth MCS results and it only takes a few days on a standard CPU server with multi-threading to handle all the ground-truth result generation.
+
+The representation learning baselines are adapted from recent graph matching techniques, specifically IMAGE-GMN (Zanfir & Sminchisescu, 2018) and IMAGE-PCA (Permutation Loss and Crossgraph Affinity) (Wang et al., 2019a). Both these methods utilize similarity scores and normalization to perform graph matching. As IMAGE-GMN uses CNN layers to form their node embeddings from images (with techniques such as Delaunay triangulation (Lee & Schachter, 1980)), we adapt the model to our task by replacing these layers with 3 GAT layers, consistent with NEURALMCS. IMAGE-PCA uses a node embedding mechanism similar to GMN, not requiring further adaptation. As the loss functions for both these methods were designed for image graphs, we alter their loss functions to binary cross entropy loss (the same as NEURALMCS).
+
+We conduct the extraction process by first removing all nodes where its corresponding summation of similarity scores across rows or columns falls below a tuneable threshold (the values of which can be found in Appendix C) in the matching matrix, then selecting an equal number of nodes in both graphs. The latter is done by maximizing the similarity scores of uniquely selected node pairs through applying the Hungarian Algorithm (Kuhn, 1955) on the remaining nodes of the matching matrix. This is because the extracted subgraphs, after just thresholding, may be of different sizes due to thresholding. The extra procedure ensures that we extract subgraphs of equal sizes and in addition, the Hungarian Algorithm yields one-to-one node-node correspondences for the extracted subgraphs. However, these methods do not necessarily result in isomorphic subgraphs.
+
+We also compare against two basic models, BASIC-GAT (Velickovic et al., 2018) and BASICGMN (Li et al., 2019), which use 3 GAT and GMN layers respectively to encode the initial node features, followed by similarity score computation. These baselines uses a simpler normalization scheme by appling element-wise sigmoid function $( y = 1 / ( 1 + e ^ { - x } ) )$ to the matching matrix, and directly feed the similarity matrix to the same loss function as defined by NEURALMCS. BASICGAT and BASIC-GMN use the same extraction method as the graph matching baselines.
+
+With exception to MCSPLIT, all these baselines run in polynomial time complexity with respect to the number of nodes in the two input graphs.
+
+# C PARAMETER SETTINGS
+
+For our model, we utilize 3 layers of GMN with 64 dimensions each for the initial embedding. We use ${ \mathrm { R e L U } } ( x ) = { \mathrm { m a x } } ( 0 , x )$ as our activation function. We fix the number of outputs for multiple choice learning to 10 on the AIDS, LINUX, and REDDIT datasets, and to 3 on the IMDB dataset. To evaluate the efficacy of multiple choice learning, we also use the same technique and settings for BASIC-GAT and BASIC-GMN. We set $\epsilon$ to $1 0 ^ { - 4 }$ , to account for numerical errors during floating point arithmetic. For the extraction procedure in our baselines, we set the threshold to 0.5 on the AIDS, LINUX, and REDDIT datasets, and to 0.7 on the IMDB dataset. We ran all experiments with Intel i7-6800K CPU and one Nvidia Titan GPU. For training, we set the batch size to 64, the learning rate to 0.001, the number of iterations to 5000, and use the Adam optimizer (Kingma & Ba,
+
+2015). All experiments were implemented with the PyTorch and PyTorch Geometric libraries (Fey & Lenssen, 2019).
+
+For more on dataset setup and training/validation/testing splits, please refer to Appendix A. For more on baseline setups, including their extraction procedure, please refer to Appendix B. For more on the extraction procedure of NEURALMCS, please refer to the main text.
+
+# D DETAILS ON EVALUATION PROCEDURE
+
+As mentioned in Section 4.1, for a graph pair $i$ in the test set, we first check whether the predicted MCS satisfies the MCS constraints or not. In this section we give more details.
+
+Denote the extracted subgraphs from the $i$ -th graph pair as $S _ { i 1 }$ and $S _ { i 2 }$ , respectively. The MCS constraint satisfaction check includes the following steps: First, we check if $S _ { i 1 }$ and $S _ { i 2 }$ are both connected (i.e. no isolated components); Second, we check if $S _ { i 1 }$ and $S _ { i 2 }$ are isomorphic to each other. Since exact isomorphism checking may take a long time in practice, we set a timeout for exact isomorphism checking, and when timeout happens, we switch to an approximate checker3. The timeout as well as the whole procedure is applied across all the methods to ensure fair comparison.
+
+When we generate $S _ { i 1 }$ and $S _ { i 2 }$ for NEURALMCS in the first place, we would take the induced subgraph, satisfying the inductivity constraint mentioned in Section 2.1. Specifically, we use the output assignment matrix $\mathbf { T }$ and check if a node has a 1 in its corresponding row (for $\mathcal { G } _ { 1 }$ ) or column (for $\mathcal { G } _ { 2 }$ ) in $_ { \mathbf { T } }$ to decide whether it is selected in the predicted MCS.
+
+Notice that by checking the size of the extracted subgraphs against the ground-truth MCS size (Equation 7 and 8), we allow equal-sized MCS results to be evaluated correctly, since for many graph pairs there are more than one correct MCS result.
+
+Here we give more insights behind the two metrics. The intuition behind the hard metric is that we only check whether the the extracted subgraphs are strictly equal to the size of the true MCS or not. However, this is too strict and does not reveal too much information about the model performance when the extracted subgraphs are not the same size as the true MCS. An easy measure would be to directly report on the predicted MCS size, but this does not take into account non-isomorphic subgraphs. The soft metric accounts for both these issues by checking the fraction of the predicted MCS size over the true MCS size only for isomorphic subgraphs. Notice that if the predicted MCS is even larger than the true MCS, the $C ( \cdot , \cdot )$ function will return 0 because it is not possible for the subgrpahs to be both larger than the true MCS (generated by the exact solver MCSPLIT) and isomorphic.
+
+# E RESULT ANALYSIS
+
+In addition to Exact $\%$ and Soft $\%$ metrics, we may also evaluate our model on the percentage of extracted subgraphs which are isomorphic $( \mathrm { I s o } \%$ ).
+
+Following the same notation used to define Exact $\%$ and Soft $\%$ , we define Iso $\%$ as follows:
+
+$$
+\mathrm { I s o ~ \% } = { \frac { \sum _ { i } ^ { N } C ( S _ { i 1 } , S _ { i 2 } ) } { N } }
+$$
+
+As seen in Table 2, NEURALMCS explicitly encodes the isomorphism constraint into the stopping condition. This is one reason why NEURALMCS is able to achieve high accuracy, especially in Soft $\%$ in Table 1. Notice, our method does not guarantee exclusion of false-positives (predicting isomorphic when not isomorphic), as it is possible for 2 differently structured graphs, with different node embeddings, to have the same subgraph embedding once all the node embeddings are aggregated. Because these situations are relatively rare (both graphs would need to have the same subgraph embedding to floating point precision), NEURALMCS is extract isomorphic subgraphs $100 \%$ of the time on the provided datasets. Our model does guarantee exclusion of false-negatives, as, if two graphs are isomorphic, our embedding propagation methodology must produce the same subgraph embeddings.
+
+Table 2: Iso $\%$ accuracy metric across four real graph datasets. All methods have been adapted for the MCS detection task. Dataset descriptions and details can be found in Appendix A.   
+
+<table><tr><td>Method</td><td>AIDS</td><td>LINUX</td><td>IMDB</td><td>REDDIT</td></tr><tr><td>McSPLIT *</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>IMAGE-GMN</td><td>0.033</td><td>19.790</td><td>N/A</td><td>20.261</td></tr><tr><td>IMAGE-PCA</td><td>0.229</td><td>22.693</td><td>38.582</td><td>33.987</td></tr><tr><td>BASIC-GAT</td><td>80.039</td><td>82.269</td><td>99.365</td><td>73.856</td></tr><tr><td>BASIC-GMN</td><td>91.183</td><td>97.230</td><td>96.924</td><td>95.425</td></tr><tr><td>NEURALMCS</td><td>100.000</td><td>100.000</td><td>100.000</td><td>100.000</td></tr></table>
+
+# F ABLATION STUDY
+
+We first form a matching matrix then extract a subgraph guided by this matrix. To form the matching matrix, we utilize representation learning to make node embeddings; compute $\boldsymbol { X }$ using similarity scores from node embeddings (Section 3.1); compute $\mathbf { Y }$ through normalization of $\boldsymbol { X }$ (Section 3.1). To perform extraction, we utilize the GUIDED SUBGRAPH EXTRACTION method proposed (Section 3.3).
+
+We perform more in-depth ablation studies to show the importance of each component whose results are shown in Table 3.
+
+Table 3: Abaltion study results on AIDS. The numbers are the “Exact $\%$ ” defined in Section 4.1.   
+
+<table><tr><td rowspan="2">Matching Matrix Computation</td><td colspan="3">Subgraph Extraction Strategy</td></tr><tr><td>GSE</td><td>Threshold</td><td>Threshold +LSAP</td></tr><tr><td>GMN+ Our Normalization</td><td>98.525 (NEURALMCS)</td><td>25.795</td><td>17.076</td></tr><tr><td>GAT+ Our Normalization</td><td>98.525</td><td>26.057</td><td>17.339</td></tr><tr><td>DGCNN+ Our Normalization</td><td>96.657</td><td>22.091</td><td>13.045</td></tr><tr><td>GMN + Sigmoid</td><td>97.083</td><td>10.521</td><td>12.488 (BASIC-GMN)</td></tr><tr><td>GMN + Sinkhorn Softmax</td><td>60.439</td><td>12.488</td><td>0.197</td></tr></table>
+
+# F.1 ON THE IMPORTANCE OF GMN
+
+GAT $^ +$ Our Normalization and DGCNN $^ +$ Our Normalization use GAT (Velickovic et al., 2018) and DGCNN (Wang et al., 2019b) used in Wang & Solomon (2019) respectively to perform node embeddings. Interestingly, when fed into our proposed GSE step, their exactly solved percentages are quite close to GMN, which is close to perfectly detecting the MCSs for all the testing pairs. Even with simpler thresholding based subgraph extraction strategies (see Section F.3 below for details), their performances are still similar to (or even better than) GMN. This seems to suggest that the choice of node embedding methods does not appear to influence the performance much when our proposed GSE strategy is used.
+
+It should be noted that earlier we used a simpler GSE strategy which always selected the node pair with the largest matching score in $\mathbf { Y }$ in during search frontier expansion. This model did not check all the possible node pairs by sorting the node matching scores and iterate through these pairs for consideration of being selected in the MCS prediction. When tested on this simpler GSE strategy, GMN indeed performed approximately $4 . 0 \%$ better than GAT and DGCNN.
+
+In summary, the choice of node embedding representation methods does not influence the performance too much, and very good accuracy can be obtained when the proposed normalization and GSE methods are both used.
+
+# F.2 ON THE IMPORTANCE OF NORMALIZATION
+
+$\mathrm { G M N } +$ Sigmoid (BASIC-GMN) uses sigmoid normalization on each individual element of the $\boldsymbol { X }$ matrix, instead of our normalization scheme (Section 3.1; Equations 1 and 2) to obtain $\mathbf { Y }$ . As sigmoid treats each node-node pair in $\mathbf { Y }$ as independent (an incorrect assumption), we see that its performance worse than our proposed normalization scheme, especially when the threshold or threshold $+ \ \mathrm { L S A P }$ strategies are used. However, similar to our findings in Section F.1, when our proposed GSE strategy is used, $\mathrm { G M N } + \mathrm { S }$ igmoid performs only slightly worse than NEURALMCS, which further confirming the usefulness of the proposed normalization scheme and the GSE method.
+
+$\mathrm { G M N } +$ Sinkhorn Softmax uses successive row- and column-wise softmax normalization (softmax to ensure that the matching matrix $\mathbf { Y }$ is in the range (0,1)) on the $\boldsymbol { X }$ matrix (similar to the Sinkhorn algorithm (Knight, 2008) used in IMAGE-PCA for image matching4) instead of our normalization scheme. As softmax does not explicitly allow nodes to go unmatched (Section 3.1), as dictated by the MCS definition, we see that our normalization procedure performs much better.
+
+As mention in Section 4.2, the assumptions made for image matching do not naturally transfer to and work well for the MCS detection task. In fact, with the simple element-wise sigmoid normalization on $\boldsymbol { X }$ , the performance is much better than the Sinkhorn normalization technique. The iterative rowand column-wise normalization on $\boldsymbol { X }$ is not a good choice for the task of MCS where nodes can remain unmatched with low scores in the final $\mathbf { Y }$ .
+
+# F.3 ON THE IMPORTANCE OF GSE
+
+For each Matching Matrix Computation method, we run 3 different subgraph extraction strategies: GSE, thresholding, and thresholding $+ \mathrm { L S A P }$ (Linear Sum Assignment Problem which we use the Hungarian algorithm (Kuhn, 1955) to solve, described in Appendix B).
+
+For thresholding, for each of the two graphs, we select the nodes whose probabilities of being included in the MCS are greater than a tunable threshold, yielding two subgraphs. We calculate such probabilities by taking the summation of rows and columns of the matching matrix $\mathbf { Y }$ . More details can be found in Appendix B.
+
+For thresholding $+ \mathrm { L S A P } ,$ , we ensure that the detected subgraphs are of equal size and have a one-toone node-node mapping (to validate their isomorphism) by running the Hungarian algorithm on the remaining rows and columns of $\mathbf { Y }$ after thresholding. We cannot run LSAP on the original $\mathbf { Y }$ since LSAP would select all nodes in the smaller of the two graphs.
+
+Neither of these simpler subgraph extraction methods enforces the subgraph isomorphism constraint, which explains their worse performance compared with GSE.
+
+We find that our major novelties (GSE and normalization technique) are the most important components in producing good performance.
+
+# G SCALABILITY STUDY
+
+is trained on graph pairs with ground-truth MCS results, which can be either obtained by MCSPLIT or the following way which provides cheap supervision without using any exact MCS solver. The high level idea of generating ground-truth MCS training pairs without exact MCS solver is to create such pairs with a smart design instead of computing MCS for any given pair of graphs. One possible way to create such pair is to extract an induced subgraph from a given graph, and the ground-truth MCS of the two graphs is naturally the extracted subgraph. More concretely, our experimental setup is as follows: We generate training graph pairs by first using the BarabsiAlbert model (Barabasi & ´ Albert, 1999) to generate 1000 graphs of size 32. For each generated graph, We randomly extract one connected 16-node subgraph from it. Each generated graph and extracted subgraph form one pair, giving a total of 1000 training graph pairs (our training set). Notice, this generation procedure allows us to know the MCSs during generation.
+
+We follow a similar procedure for testing set, where we use the Barabsi-Albert model to generate 100 graphs of size 16, 32, 64, and 128 (denoted as “Test Dataset Size” in the table below). For each generated graph, we extract one connected 8-, 16-, 32-, and 64- node subgraph respectively. This gives us 5 test sets, each with 100 graph pairs.
+
+We use the following 5 metrics for thorough evaluation:
+
+1. Solved $\%$ : It measures the percentage of pairs that the model can successfully finish within 100 seconds.   
+2. Soft $\%$ : It measures the fraction of the predicted MCS size over the true MCS size for the isomorphic extracted subgraphs (Appendix D).   
+3. Iso $\%$ : Among the pairs that can be solved within the time budget, it measures the percentage of pairs whose extracted subgraphs are isomorphic. This is an important metric because subgraph isomorphism is a key constraint required by the definition of MCS.   
+4. Dev in $\#$ nodes: among the pairs that can be solved within the time budget, it measures the average deviation of the number of nodes in the predicted MCS versus the number of nodes in the true MCS. The range of this metric is $[ 0 , N ]$ where $\mathbf { N }$ is the number of nodes of the largest graph in a dataset. This metric gives a more intuitive understanding of the performance of a model compared to “Soft $\%$ ” since it reports the number of nodes directly.   
+5. (Average) Runtime (msec): It measures the average running time per testing pairs that the model solves within the time budget. In other words, if a model fails at solving a pair within the time budget, the runtime will NOT be taken into account by this metric for fair comparison
+
+We set the time budget to 100 seconds and 500 seconds for MCSPLIT respectively, and the results are shown in Table 4.
+
+Table 4: Scalability study results on AIDS.   
+
+<table><tr><td>Test Dataset size</td><td>Metrics</td><td>MCSPLIT (100s)</td><td>MCSPLIT (500s)</td><td>McSPLIT</td></tr><tr><td rowspan="5">16</td><td>Solved %</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>Soft %</td><td>100.000</td><td>100.000</td><td>99.625</td></tr><tr><td>Iso %</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>Dev in # nodes</td><td>0</td><td>0</td><td>0.030</td></tr><tr><td>Runtime (msec)</td><td>295.576</td><td>236.502</td><td>550.688</td></tr><tr><td rowspan="5">32</td><td>Solved %</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>Soft %</td><td>100.000</td><td>100.000</td><td>99.563</td></tr><tr><td>Iso %</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>Dev in # nodes</td><td>0</td><td>0</td><td>0.070</td></tr><tr><td>Runtime (msec)</td><td>333.793</td><td>340.310</td><td>787.901</td></tr><tr><td rowspan="5">64</td><td>Solved %</td><td>61.000</td><td>62.000</td><td>100.000</td></tr><tr><td>Soft %</td><td>61.000</td><td>62.000</td><td>98.843</td></tr><tr><td>Iso %</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>Dev in # nodes</td><td>0</td><td>0</td><td>0.370</td></tr><tr><td>Runtime (msec)</td><td>4509.056</td><td>10351.813</td><td>940.581</td></tr><tr><td rowspan="5">128</td><td>Solved %</td><td>26.000</td><td>28.000</td><td>100.000</td></tr><tr><td>Soft %</td><td>26.000</td><td>28.000</td><td>75.484</td></tr><tr><td>Iso %</td><td>100.000</td><td>100.000</td><td>100.000</td></tr><tr><td>Dev in # nodes</td><td>0</td><td>0</td><td>15.690</td></tr><tr><td>Runtime (msec)</td><td>1220.117</td><td>18809.848</td><td>1194.089</td></tr></table>
+
+NEURALMCS achieves performance close to the exact ground truth solver in terms of accuracy, and can scale to much larger graphs which the exact solver fails, most of the time, at solving within the time budget.
+
+For accuracy, we see that the size of MCS extracted for the model is often over $98 \%$ the true MCS size. Interestingly, for graphs of size 64, we find that the extracted subgraphs differ between our model and the true MCS only in less than one node (0.37 nodes) on average. This indicates that our proposed method (NEURALMCS) can detect MCS that the current state of the art (MCSPLIT) cannot, due to our careful design and the incorporation of learning algorithms.
+
+For running time, our model is comparable to or slower than the ground truth detector for simpler cases (¡ 1 second) but much faster for larger graphs. This could be due to our model incurring overhead from Python implementation, while MCSPLIT is implemented in $\mathrm { C } { + } { + }$ . However, when the dataset size equals 128, MCSPLIT fails for most pairs, as the MCS problem is NP-hard, while NEURALMCS can solve all the pairs due to guaranteed time complexity (Section 3.4). Notice, there is no theoretical time complexity guarantee for MCSPLIT (exponential time complexity in the worst case (McCreesh et al., 2017)), resulting in significant average running time increase from 1220.1 msec to 18809.8 msec when only 2 additional pairs are solved by increasing the time budget from 100 seconds to 500 seconds. In fact, we observed that the actual running time of the branch-andbound algorithm MCSPLIT strongly depends on the actual graph structures varying from graph to graph.
+
+In summary, when graphs are larger and larger, MCSPLIT quickly becomes almost unusable in practice due to an inability to yield results most of the time, while NEURALMCS still extracts highaccuracy MCSs consistently and runs much faster than MCSPLIT with guaranteed theoretical time complexity. In practice, we observe that our model can run successfully on a 12-GB GPU until 4000-node graphs when the GPU runs out of memory, in which case MCSPLIT almost surely cannot be used either.
+
+# H DISCUSSION ON SUBGRAPH ISOMORPHISM CHECKING OF GUIDED SUBGRAPH EXTRACTION
+
+In the proposed GUIDED SUBGRAPH EXTRACTION (GSE) strategy (Section 3.3.1), we check if the inclusion of a new node pair would result in two isomorphic subgraphs by checking if $| | \mathbf { w } _ { 1 } - \pmb { w } _ { 2 } | |$ is smaller than or equal to a threshold, which is a criteria that allows us to punish mismatched nodes more softly. While an iterative check would achieve efficiency benefits by avoiding computing the subgraph embeddings, it assumes at every step we have performed a non-ambiguous matching. For example, suppose we have 2 graphs, where in the current iteration of GSE, we have 2 fully connected 3-node subgraphs currently extracted with node-node mappings. We label the node ids of these 2 graphs as 1-2-3 and a-b-c respectively and the mappings as 1-a, 2-b, 3-c. If we select a new node 4 from $\mathcal { G } _ { 1 }$ and a new node d from $\mathcal { G } _ { 2 }$ and 4 is connected to 2 and d is connected to a, an iterative procedure would not be able to tell that the addition of node 4 and d to the MCS is valid (since 2-b is matched but NOT 2-a). Fundamentally, the structure for 1,2,3 and a,b,c are similar, so it is uncertain (and expected) that the computed node matchings would be 2-a, 1-b or 2-b, 1-a.
+
+In contrast, our proposed checking strategy can account for the above-mentioned uncertainty by doing aggregation of node embeddings to obtain subgraph-level embeddings $w _ { 1 }$ and $w _ { 2 }$ , since this does not involve explicitly finding the node-node mappings. Instead, it checks the isomorphism in a more principled way borrowing insights from Weisfeiler-Lehman (WL) graph isomorphism test (Shervashidze et al., 2011). In WL, each node in the two graphs is represented as an aggregation of local node features, and each graph is represented as an aggregation of node labels. The algorithm stops and decides two graphs are not isomorphic when the two graph-level node label sets are different. In our model, the graph-level node label set is equivalent to ${ \pmb w } _ { 1 }$ and ${ \pmb w } _ { 2 }$ , and our GSE decides that the subgraphs are not isomorphic when the two graph-level representations are different enough.
+
+In conclusion, our proposed checking strategy addresses the ambiguous node mapping issue which the iterative isomorphism check could not solve, and is theoretically connected to the WL algorithm for graph isomorphism test.
+
+# I DISCUSSION ON LEARNINING CAPACITY OF GUIDED SUBGRAPH EXTRACTION
+
+In our current model, we form a matching matrix for both training and inference, and perform our loss function on the matching matrix during training (Section 3.2), and utilize GSE (Section 3.3) guided by the matching matrix during inference to extract subgraphs. We use GMN for node embeddings (Section 2.2 and Section 3.1) and feed the matching matrix into GSE, which is fixed during the iterative GSE process. However, one potential issue is that once a node pair is selected, the extracted subgraph grows by one node causing the candidate pairs to change in the next iteration.
+
+Ideally, node embeddings should be updated to reflect such change after each iteration. By introducing learnable components to iteratively update the node embeddings to reflect such change, we can train the GSE component using guidance from the ground-truth node mappings in the MCS, making the training stage and inference stage consistent and match each other.
+
+To accomplish this, we propagate the node embeddings at each iteration of GSE with learnable weights to recompute the matching matrix $\mathbf { Y }$ such that the next iteration’s node embeddings will be conditionally updated based on the current extracted subgraph. To achieve it, we extend GMN to update the node embeddings for the extracted subgraph at each GSE iteration. GMN updates the node embeddings of two graphs jointly by performing intra- and inter-graph message passing. Thus, one can directly apply GMN to the extracted subgraph at each GSE iteration, and calculate the loss function at the end of GSE process (replacing the current BCE loss on the matching matrix $\mathbf { Y }$ ), achieving conditional node embeddings in the GSE step of the model.
+
+In implementation, we make a further modification to GMN by not propagating to matched nodes in the two extracted subgraphs. This is because we want the node embeddings for the currently extracted isomorphic subgraphs to stay as consistent as possible and not be influenced by any unpicked nodes in the larger graph or any nodes from the opposing graph.
+
+We run both modified versions (with and without further modification) of NEURALMCS on AIDS, and the performance increase is only marginal $( < 1 \%$ increase). Therefore, by forgoing this step during training and only using GSE only during testing, we can gain a free speed up in training time.
+
+# J MORE CASE STUDY
+
+All case study plots can be seen in Figure 5. We see that our model is able to differentiate difficult input pairs, where adding any extra nodes would break the MCS constraints. In the LINUX, IMDB, and REDDIT dataset, we see examples where the graph structures are vastly different, yet NEURALMCS is still able to correctly differentiate MCS nodes. In the AIDS dataset, we see the model is able to successfully extract subgraphs which maintain node labels. In the IMDB dataset, we see the model can handle denser and larger size graphs.
+
+![](images/dcc1a7d11a3d319ccde8b6d7a60b58d09f71722a5141adadf63135d03c640877.jpg)  
+Figure 5: Case study.

parse/train/S1c2cvqee/S1c2cvqee.md

@@ -0,0 +1,308 @@
+# DESIGNING NEURAL NETWORK ARCHITECTURES USING REINFORCEMENT LEARNING
+
+Bowen Baker, Otkrist Gupta, Nikhil Naik & Ramesh Raskar
+
+Media Laboratory   
+Massachusetts Institute of Technology   
+Cambridge MA 02139, USA   
+{bowen, otkrist, naik, raskar}@mit.edu
+
+# ABSTRACT
+
+At present, designing convolutional neural network (CNN) architectures requires both human expertise and labor. New architectures are handcrafted by careful experimentation or modified from a handful of existing networks. We introduce MetaQNN, a meta-modeling algorithm based on reinforcement learning to automatically generate high-performing CNN architectures for a given learning task. The learning agent is trained to sequentially choose CNN layers using $Q$ - learning with an $\epsilon$ -greedy exploration strategy and experience replay. The agent explores a large but finite space of possible architectures and iteratively discovers designs with improved performance on the learning task. On image classification benchmarks, the agent-designed networks (consisting of only standard convolution, pooling, and fully-connected layers) beat existing networks designed with the same layer types and are competitive against the state-of-the-art methods that use more complex layer types. We also outperform existing meta-modeling approaches for network design on image classification tasks.
+
+# 1 INTRODUCTION
+
+Deep convolutional neural networks (CNNs) have seen great success in the past few years on a variety of machine learning problems (LeCun et al., 2015). A typical CNN architecture consists of several convolution, pooling, and fully connected layers. While constructing a CNN, a network designer has to make numerous design choices: the number of layers of each type, the ordering of layers, and the hyperparameters for each type of layer, e.g., the receptive field size, stride, and number of receptive fields for a convolution layer. The number of possible choices makes the design space of CNN architectures extremely large and hence, infeasible for an exhaustive manual search. While there has been some work (Pinto et al., 2009; Bergstra et al., 2013; Domhan et al., 2015) on automated or computer-aided neural network design, new CNN architectures or network design elements are still primarily developed by researchers using new theoretical insights or intuition gained from experimentation.
+
+In this paper, we seek to automate the process of CNN architecture selection through a metamodeling procedure based on reinforcement learning. We construct a novel $Q$ -learning agent whose goal is to discover CNN architectures that perform well on a given machine learning task with no human intervention. The learning agent is given the task of sequentially picking layers of a CNN model. By discretizing and limiting the layer parameters to choose from, the agent is left with a finite but large space of model architectures to search from. The agent learns through random exploration and slowly begins to exploit its findings to select higher performing models using the $\epsilon \cdot$ - greedy strategy (Mnih et al., 2015). The agent receives the validation accuracy on the given machine learning task as the reward for selecting an architecture. We expedite the learning process through repeated memory sampling using experience replay (Lin, 1993). We refer to this $Q$ -learning based meta-modeling method as MetaQNN, which is summarized in Figure 1.1
+
+We conduct experiments with a space of model architectures consisting of only standard convolution, pooling, and fully connected layers using three standard image classification datasets: CIFAR-10,
+
+![](images/46d5c58f33c694a26ef479826deb91e729210b90ab747d2d227eb608e4fdeb87.jpg)  
+Figure 1: Designing CNN Architectures with $Q$ -learning: The agent begins by sampling a Convolutional Neural Network (CNN) topology conditioned on a predefined behavior distribution and the agent’s prior experience (left block). That CNN topology is then trained on a specific task; the topology description and performance, e.g. validation accuracy, are then stored in the agent’s memory (middle block). Finally, the agent uses its memories to learn about the space of CNN topologies through $Q$ -learning (right block).
+
+SVHN, and MNIST. The learning agent discovers CNN architectures that beat all existing networks designed only with the same layer types (e.g., Springenberg et al. (2014); Srivastava et al. (2015)). In addition, their performance is competitive against network designs that include complex layer types and training procedures (e.g., Clevert et al. (2015); Lee et al. (2016)). Finally, the MetaQNN selected models comfortably outperform previous automated network design methods (Stanley & Miikkulainen, 2002; Bergstra et al., 2013). The top network designs discovered by the agent on one dataset are also competitive when trained on other datasets, indicating that they are suited for transfer learning tasks. Moreover, we can generate not just one, but several varied, well-performing network designs, which can be ensembled to further boost the prediction performance.
+
+# 2 RELATED WORK
+
+Designing neural network architectures: Research on automating neural network design goes back to the 1980s when genetic algorithm-based approaches were proposed to find both architectures and weights (Schaffer et al., 1992). However, to the best of our knowledge, networks designed with genetic algorithms, such as those generated with the NEAT algorithm (Stanley & Miikkulainen, 2002), have been unable to match the performance of hand-crafted networks on standard benchmarks (Verbancsics & Harguess, 2013). Other biologically inspired ideas have also been explored; motivated by screening methods in genetics, Pinto et al. (2009) proposed a high-throughput network selection approach where they randomly sample thousands of architectures and choose promising ones for further training. In recent work, Saxena & Verbeek (2016) propose to sidestep the architecture selection process through densely connected networks of layers, which come closer to the performance of hand-crafted networks.
+
+Bayesian optimization has also been used (Shahriari et al., 2016) for automatic selection of network architectures (Bergstra et al., 2013; Domhan et al., 2015) and hyperparameters (Snoek et al., 2012; Swersky et al., 2013). Notably, Bergstra et al. (2013) proposed a meta-modeling approach based on Tree of Parzen Estimators (TPE) (Bergstra et al., 2011) to choose both the type of layers and hyperparameters of feed-forward networks; however, they fail to match the performance of handcrafted networks.
+
+Reinforcement Learning: Recently there has been much work at the intersection of reinforcement learning and deep learning. For instance, methods using CNNs to approximate the $Q$ -learning utility function (Watkins, 1989) have been successful in game-playing agents (Mnih et al., 2015; Silver et al., 2016) and robotic control (Lillicrap et al., 2015; Levine et al., 2016). These methods rely on phases of exploration, where the agent tries to learn about its environment through sampling, and exploitation, where the agent uses what it learned about the environment to find better paths. In traditional reinforcement learning settings, over-exploration can lead to slow convergence times, yet over-exploitation can lead to convergence to local minima (Kaelbling et al., 1996). However, in the case of large or continuous state spaces, the $\epsilon$ -greedy strategy of learning has been empirically shown to converge (Vermorel & Mohri, 2005). Finally, when the state space is large or exploration is costly, the experience replay technique (Lin, 1993) has proved useful in experimental settings (Adam et al., 2012; Mnih et al., 2015). We incorporate these techniques— $Q$ -learning, the $\epsilon$ -greedy strategy and experience replay—in our algorithm design.
+
+# 3 BACKGROUND
+
+Our method relies on $Q$ -learning, a type of reinforcement learning. We now summarize the theoretical formulation of $Q$ -learning, as adopted to our problem. Consider the task of teaching an agent to find optimal paths as a Markov Decision Process (MDP) in a finite-horizon environment. Constraining the environment to be finite-horizon ensures that the agent will deterministically terminate in a finite number of time steps. In addition, we restrict the environment to have a discrete and finite state space $s$ as well as action space $\mathcal { U }$ . For any state $s _ { i } \in S$ , there is a finite set of actions, $\mathcal { U } ( s _ { i } ) \subseteq \mathcal { U }$ , that the agent can choose from. In an environment with stochastic transitions, an agent in state $s _ { i }$ taking some action $u \in \mathcal { U } ( s _ { i } )$ will transition to state $s _ { j }$ with probability $p _ { s ^ { \prime } | s , u } ( s _ { j } | s _ { i } , u )$ , which may be unknown to the agent. At each time step $t$ , the agent is given a reward $r _ { t }$ , dependent on the transition from state $s$ to $s ^ { \prime }$ and action $u$ . $r _ { t }$ may also be stochastic according to a distribution $p _ { r | s ^ { \prime } , s , u }$ . The agent’s goal is to maximize the total expected reward over all possible trajectories, i.e., $\operatorname* { m i n } _ { \mathbf { \zeta } } { } _ { T _ { i } \in \mathcal { T } } { \cal R } _ { T _ { i } }$ , where the total expected reward for a trajectory $\mathcal { T } _ { i }$ is
+
+$$
+\begin{array} { r } { R _ { \mathcal { T } _ { i } } = \sum _ { ( s , u , s ^ { \prime } ) \in \mathcal { T } _ { i } } \mathbb { E } _ { r | s , u , s ^ { \prime } } [ r | s , u , s ^ { \prime } ] . } \end{array}
+$$
+
+Though we limit the agent to a finite state and action space, there are still a combinatorially large number of trajectories, which motivates the use of reinforcement learning. We define the maximization problem recursively in terms of subproblems as follows. For any state $s _ { i } \in S$ and subsequent action $u \in \mathcal { U } ( s _ { i } )$ , we define the maximum total expected reward to be $Q ^ { * } ( s _ { i } , u )$ . $Q ^ { * } ( \cdot )$ is known as the action-value function and individual $Q ^ { * } ( s _ { i } , u )$ are know as $Q$ -values. The recursive maximization equation, which is known as Bellman’s Equation, can be written as
+
+$$
+\begin{array} { r } { Q ^ { * } ( s _ { i } , u ) = \mathbb { E } _ { s _ { j } \mid s _ { i } , u } \left[ \mathbb { E } _ { r \mid s _ { i } , u , s _ { j } } [ r \mid s _ { i } , u , s _ { j } ] + \gamma \operatorname* { m a x } _ { u ^ { \prime } \in \mathcal { U } ( s _ { j } ) } Q ^ { * } ( s _ { j } , u ^ { \prime } ) \right] . } \end{array}
+$$
+
+In many cases, it is impossible to analytically solve Bellman’s Equation (Bertsekas, 2015), but it can be formulated as an iterative update
+
+$$
+\begin{array} { r } { Q _ { t + 1 } ( s _ { i } , u ) = ( 1 - \alpha ) Q _ { t } ( s _ { i } , u ) + \alpha \left[ r _ { t } + \gamma \operatorname* { m a x } _ { u ^ { \prime } \in \mathcal { U } ( s _ { j } ) } Q _ { t } ( s _ { j } , u ^ { \prime } ) \right] . } \end{array}
+$$
+
+Equation 3 is the simplest form of $Q$ -learning proposed by Watkins (1989). For well formulated problems, $\begin{array} { r } { \operatorname* { l i m } _ { t \to \infty } \bar { Q _ { t } } ( s , u ) = Q ^ { * } ( s , u ) } \end{array}$ , as long as each transition is sampled infinitely many times (Bertsekas, 2015). The update equation has two parameters: (i) $\alpha$ is a $Q$ -learning rate which determines the weight given to new information over old information, and (ii) $\gamma$ is the discount factor which determines the weight given to short-term rewards over future rewards. The $Q$ -learning algorithm is model-free, in that the learning agent can solve the task without ever explicitly constructing an estimate of environmental dynamics. In addition, $Q$ -learning is off policy, meaning it can learn about optimal policies while exploring via a non-optimal behavioral distribution, i.e. the distribution by which the agent explores its environment.
+
+We choose the behavior distribution using an $\epsilon$ -greedy strategy (Mnih et al., 2015). With this strategy, a random action is taken with probability $\epsilon$ and the greedy action, $\begin{array} { r } { \operatorname* { m a x } _ { u \in \mathcal { U } ( s _ { i } ) } Q _ { t } \mathopen { } \mathclose \bgroup \left( s _ { i } , u \aftergroup \egroup \right) } \end{array}$ , is chosen with probability $1 - \epsilon$ . We anneal $\epsilon$ from $1  0$ such that the agent begins in an exploration phase and slowly starts moving towards the exploitation phase. In addition, when the exploration cost is large (which is true for our problem setting), it is beneficial to use the experience replay technique for faster convergence (Lin, 1992). In experience replay, the learning agent is provided with a memory of its past explored paths and rewards. At a given interval, the agent samples from the memory and updates its $Q$ -values via Equation 3.
+
+# 4 DESIGNING NEURAL NETWORK ARCHITECTURES WITH $Q$ -LEARNING
+
+We consider the task of training a learning agent to sequentially choose neural network layers. Figure 2 shows feasible state and action spaces (a) and a potential trajectory the agent may take along with the CNN architecture defined by this trajectory (b). We model the layer selection process as a Markov Decision Process with the assumption that a well-performing layer in one network should also perform well in another network. We make this assumption based on the hierarchical nature of the feature representations learned by neural networks with many hidden layers (LeCun et al., 2015). The agent sequentially selects layers via the $\epsilon$ -greedy strategy until it reaches a termination state. The CNN architecture defined by the agent’s path is trained on the chosen learning problem, and the agent is given a reward equal to the validation accuracy. The validation accuracy and architecture description are stored in a replay memory, and experiences are sampled periodically from the replay memory to update $Q$ -values via Equation 3. The agent follows an $\epsilon$ schedule which determines its shift from exploration to exploitation.
+
+![](images/dee80030fc5fc1b6ad35a44d75d773edc835d64b20e4221813dc684b9dea8980.jpg)  
+Figure 2: Markov Decision Process for CNN Architecture Generation: Figure 2(a) shows the full state and action space. In this illustration, actions are shown to be deterministic for clarity, but they are stochastic in experiments. $C ( n , f , l )$ denotes a convolutional layer with $n$ filters, receptive field size $f$ , and stride l. $P ( f , l )$ denotes a pooling layer with receptive field size $f$ and stride l. $G$ denotes a termination state (Softmax/Global Average Pooling). Figure 2(b) shows a path the agent may choose, highlighted in green, and the corresponding CNN topology.
+
+Our method requires three main design choices: (i) reducing CNN layer definitions to simple state tuples, (ii) defining a set of actions the agent may take, i.e., the set of layers the agent may pick next given its current state, and (iii) balancing the size of the state-action space—and correspondingly, the model capacity—with the amount of exploration needed by the agent to converge. We now describe the design choices and the learning process in detail.
+
+# 4.1 THE STATE SPACE
+
+Each state is defined as a tuple of all relevant layer parameters. We allow five different types of layers: convolution (C), pooling (P), fully connected (FC), global average pooling (GAP), and softmax (SM), though the general method is not limited to this set. Table 1 shows the relevant parameters for each layer type and also the discretization we chose for each parameter. Each layer has a parameter layer depth (shown as Layer $1 , 2 , \ldots$ in Figure 2). Adding layer depth to the state space allows us to constrict the action space such that the state-action graph is directed and acyclic (DAG) and also allows us to specify a maximum number of layers the agent may select before terminating.
+
+Each layer type also has a parameter called representation size $R$ -size). Convolutional nets progressively compress the representation of the original signal through pooling and convolution. The presence of these layers in our state space may lead the agent on a trajectory where the intermediate signal representation gets reduced to a size that is too small for further processing. For example, five $2 \times 2$ pooling layers each with stride 2 will reduce an image of initial size $3 2 \times 3 2$ to size $1 \times 1$ . At this stage, further pooling, or convolution with receptive field size greater than 1, would be meaningless and degenerate. To avoid such scenarios, we add the $R$ -size parameter to the state tuple $s$ , which allows us to restrict actions from states with $R$ -size $n$ to those that have a receptive field size less than or equal to $n$ . To further constrict the state space, we chose to bin the representation sizes into three discrete buckets. However, binning adds uncertainty to the state transitions: depending on the true underlying representation size, a pooling layer may or may not change the $R$ -size bin. As a result, the action of pooling can lead to two different states, which we model as stochasticity in state transitions. Please see Figure A1 in appendix for an illustrated example.
+
+<table><tr><td rowspan=1 colspan=1>Layer Type</td><td rowspan=1 colspan=1>LayerParameters</td><td rowspan=1 colspan=1>ParameterValues</td></tr><tr><td rowspan=1 colspan=1>Convolution (C)</td><td rowspan=1 colspan=1>i~Layer depthf~Receptive field sizel~Strided ~ # receptive fieldsn ~ Representation size</td><td rowspan=1 colspan=1>&lt;12Square. ∈ {1,3,5}Square.Always equal to 1∈{64,128,256,512}∈{(,8],(8,4],（4,1]}</td></tr><tr><td rowspan=1 colspan=1>Pooling (P)</td><td rowspan=1 colspan=1>i~Layer depth(f,l)~ (Receptive field size, Strides)n ~ Representation size</td><td rowspan=1 colspan=1>&lt;12Square.∈{(5,3),(3,2),(2,2)}∈{(∞,8],(8,4] and (4,1]}</td></tr><tr><td rowspan=1 colspan=1>Fully Connected (FC)</td><td rowspan=1 colspan=1>i~Layerdepthn ~ # consecutive FC layersd ~# neurons</td><td rowspan=1 colspan=1>&lt;12&lt;3∈ {512,256,128}</td></tr><tr><td rowspan=1 colspan=1>Termination State</td><td rowspan=1 colspan=1>S~Previous Statet~Type</td><td rowspan=1 colspan=1>Global Avg.Pooling/Softmax</td></tr></table>
+
+Table 1: Experimental State Space. For each layer type, we list the relevant parameters and the values each parameter is allowed to take.
+
+# 4.2 THE ACTION SPACE
+
+We restrict the agent from taking certain actions to both limit the state-action space and make learning tractable. First, we allow the agent to terminate a path at any point, i.e. it may choose a termination state from any non-termination state. In addition, we only allow transitions for a state with layer depth $i$ to a state with layer depth $i + 1$ , which ensures that there are no loops in the graph. This constraint ensures that the state-action graph is always a DAG. Any state at the maximum layer depth, as prescribed in Table 1, may only transition to a termination layer.
+
+Next, we limit the number of fully connected (FC) layers to be at maximum two, because a large number of FC layers can lead to too may learnable parameters. The agent at a state with type FC may transition to another state with type FC if and only if the number of consecutive FC states is less than the maximum allowed. Furthermore, a state $s$ of type FC with number of neurons $d$ may only transition to either a termination state or a state $s ^ { \prime }$ of type FC with number of neurons $d ^ { \prime } \leq d$ .
+
+An agent at a state of type convolution (C) may transition to a state with any other layer type. An agent at a state with layer type pooling (P) may transition to a state with any other layer type other than another $\mathrm { \bf P }$ state because consecutive pooling layers are equivalent to a single, larger pooling layer which could lie outside of our chosen state space. Furthermore, only states with representation size in bins (8, 4] and (4, 1] may transition to an FC layer, which ensures that the number of weights does not become unreasonably huge. Note that a majority of these constraints are in place to enable faster convergence on our limited hardware (see Section 5) and not a limitation of the method in itself.
+
+# 4.3 $Q$ -LEARNING TRAINING PROCEDURE
+
+For the iterative $Q$ -learning updates (Equation 3), we set the $Q$ -learning rate $( \alpha )$ to 0.01. In addition, we set the discount factor $( \gamma )$ to 1 to not over-prioritize short-term rewards. We decrease $\epsilon$ from 1.0 to 0.1 in steps, where the step-size is defined by the number of unique models trained (Table 2). At $\epsilon = 1 . 0$ , the agent samples CNN architecture with a random walk along a uniformly weighted Markov chain. Every topology sampled by the agent is trained using the procedure described in Section 5, and the prediction performance of this network topology on the validation set is recorded. We train a larger number of models at $\epsilon = 1 . 0$ as compared to other values of $\epsilon$ to ensure that the agent has adequate time to explore before it begins to exploit. We stop the agent at $\epsilon = 0 . 1$ (and not at $\epsilon = 0$ ) to obtain a stochastic final policy, which generates perturbations of the global minimum.2 Ideally, we want to identify several well-performing model topologies, which can then be ensembled to improve prediction performance.
+
+During the entire training process (starting at $\epsilon = 1 . 0$ ), we maintain a replay dictionary which stores (i) the network topology and (ii) prediction performance on a validation set, for all of the sampled
+
+<table><tr><td rowspan=1 colspan=1>E</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>0.7</td><td rowspan=1 colspan=1>0.6</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.4</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.2</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>#ModelsTrained</td><td rowspan=1 colspan=1>1500</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td></tr></table>
+
+Table 2:  Schedule. The learning agent trains the specified number of unique models at each .
+
+models. If a model that has already been trained is re-sampled, it is not re-trained, but instead the previously found validation accuracy is presented to the agent. After each model is sampled and trained, the agent randomly samples 100 models from the replay dictionary and applies the $Q$ -value update defined in Equation 3 for all transitions in each sampled sequence. The $Q$ -value update is applied to the transitions in temporally reversed order, which has been shown to speed up $Q$ -values convergence (Lin, 1993).
+
+# 5 EXPERIMENT DETAILS
+
+During the model exploration phase, we trained each network topology with a quick and aggressive training scheme. For each experiment, we created a validation set by randomly taking 5,000 samples from the training set such that the resulting class distributions were unchanged. For every network, a dropout layer was added after every two layers. The $i ^ { t h }$ dropout layer, out of a total $n$ dropout layers, had a dropout probability of $\dot { \frac { \ i } { 2 n } }$ . Each model was trained for a total of 20 epochs with the Adam optimizer (Kingma & Ba, 2014) with $\beta _ { 1 } = 0 . 9$ , $\beta _ { 2 } = 0 . 9 9 9$ , $\varepsilon = 1 0 ^ { - 8 }$ . The batch size was set to 128, and the initial learning rate was set to 0.001. If the model failed to perform better than a random predictor after the first epoch, we reduced the learning rate by a factor of 0.4 and restarted training, for a maximum of 5 restarts. For models that started learning (i.e., performed better than a random predictor), we reduced the learning rate by a factor of 0.2 every 5 epochs. All weights were initialized with Xavier initialization (Glorot & Bengio, 2010). Our experiments using Caffe (Jia et al., 2014) took 8-10 days to complete for each dataset with a hardware setup consisting of 10 NVIDIA GPUs.
+
+After the agent completed the $\epsilon$ schedule (Table 2), we selected the top ten models that were found over the course of exploration. These models were then finetuned using a much longer training schedule, and only the top five were used for ensembling. We now provide details of the datasets and the finetuning process.
+
+The Street View House Numbers (SVHN) dataset has 10 classes with a total of 73,257 samples in the original training set, 26,032 samples in the test set, and 531,131 additional samples in the extended training set. During the exploration phase, we only trained with the original training set, using 5,000 random samples as validation. We finetuned the top ten models with the original plus extended training set, by creating preprocessed training and validation sets as described by Lee et al. (2016). Our final learning rate schedule after tuning on validation set was 0.025 for 5 epochs, 0.0125 for 5 epochs, 0.0001 for 20 epochs, and 0.00001 for 10 epochs.
+
+CIFAR-10, the 10 class tiny image dataset, has 50,000 training samples and 10,000 testing samples. During the exploration phase, we took 5,000 random samples from the training set for validation. The maximum layer depth was increased to 18. After the experiment completed, we used the same validation set to tune hyperparameters, resulting in a final training scheme which we ran on the entire training set. In the final training scheme, we set a learning rate of 0.025 for 40 epochs, 0.0125 for 40 epochs, 0.0001 for 160 epochs, and 0.00001 for 60 epochs, with all other parameters unchanged. During this phase, we preprocess using global contrast normalization and use moderate data augmentation, which consists of random mirroring and random translation by up to 5 pixels.
+
+MNIST, the 10 class handwritten digits dataset, has 60,000 training samples and 10,000 testing samples. We preprocessed each image with global mean subtraction. In the final training scheme, we trained each model for 40 epochs and decreased learning rate every 5 epochs by a factor of 0.2. For further tuning details please see Appendix C.
+
+# 6 RESULTS
+
+Model Selection Analysis: From $Q$ -learning principles, we expect the learning agent to improve in its ability to pick network topologies as $\epsilon$ reduces and the agent enters the exploitation phase. In
+
+![](images/32552c045952a2108296dbbf36564ad8f0b5f3075473a34e23667ff0fce72559.jpg)
+
+![](images/818d2c4b19fb2d138b036e932e80d2c5a38257b0bfc2910a1ad197b14962fe53.jpg)  
+Figure 3: $Q$ -Learning Performance. In the plots, the blue line shows a rolling mean of model accuracy versus iteration, where in each iteration of the algorithm the agent is sampling a model. Each bar (in light blue) marks the average accuracy over all models that were sampled during the exploration phase with the labeled $\epsilon$ . As $\epsilon$ decreases, the average accuracy goes up, demonstrating that the agent learns to select better-performing CNN architectures.
+
+Table 3: Error Rate Comparison with CNNs that only use convolution, pooling, and fully connected layers. We report results for CIFAR-10 and CIFAR-100 with moderate data augmentation and results for MNIST and SVHN without any data augmentation.   
+
+<table><tr><td>Method</td><td>CIFAR-10</td><td>SVHN</td><td>MNIST</td><td>CIFAR-100</td></tr><tr><td>Maxout (Goodfellow et al., 2013)</td><td>9.38</td><td>2.47</td><td>0.45</td><td>38.57</td></tr><tr><td>NIN (Lin et al., 2013)</td><td>8.81</td><td>2.35</td><td>0.47</td><td>35.68</td></tr><tr><td>FitNet (Romero et al., 2014)</td><td>8.39</td><td>2.42</td><td>0.51</td><td>35.04</td></tr><tr><td>HighWay (Srivastava et al.,2015)</td><td>7.72</td><td>-</td><td></td><td></td></tr><tr><td>VGGnet (Simonyan &amp; Zisserman,2014)</td><td>7.25</td><td>=</td><td>=</td><td>=</td></tr><tr><td>All-CNN (Springenberg et al., 2014)</td><td>7.25</td><td>=</td><td>=</td><td>33.71</td></tr><tr><td>MetaQNN (ensemble)</td><td>7.32</td><td>2.06</td><td>0.32</td><td>-</td></tr><tr><td>MetaQNN (top model)</td><td>6.92</td><td>2.28</td><td>0.44</td><td>27.14*</td></tr></table>
+
+Figure 3, we plot the rolling mean of prediction accuracy over 100 models and the mean accuracy of models sampled at different $\epsilon$ values, for the CIFAR-10 and SVHN experiments. The plots show that, while the prediction accuracy remains flat during the exploration phase $\epsilon = 1$ ) as expected, the agent consistently improves in its ability to pick better-performing models as $\epsilon$ reduces from 1 to 0.1. For example, the mean accuracy of models in the SVHN experiment increases from $5 2 . 2 5 \%$ at $\epsilon = 1$ to $8 8 . 0 2 \%$ at $\epsilon = 0 . 1$ . Furthermore, we demonstrate the stability of the $Q$ -learning procedure with 10 independent runs on a subset of the SVHN dataset in Section D.1 of the Appendix. Additional analysis of $Q$ -learning results can be found in Section D.2.
+
+The top models selected by the $Q$ -learning agent vary in the number of parameters but all demonstrate high performance (see Appendix Tables 1-3). For example, the number of parameters for the top five CIFAR-10 models range from 11.26 million to 1.10 million, with only a $2 . 3 2 \%$ decrease in test error. We find design motifs common to the top hand-crafted network architectures as well. For example, the agent often chooses a layer of type $C ( N , 1 , 1 )$ as the first layer in the network. These layers generate $N$ learnable linear transformations of the input data, which is similar in spirit to preprocessing of input data from RGB to a different color spaces such as YUV, as found in prior work (Sermanet et al., 2012; 2013).
+
+Prediction Performance: We compare the prediction performance of the MetaQNN networks discovered by the $Q$ -learning agent with state-of-the-art methods on three datasets. We report the accuracy of our best model, along with an ensemble of top five models. First, we compare MetaQNN with six existing architectures that are designed with standard convolution, pooling, and fully-connected layers alone, similar to our designs. As seen in Table 3, our top model alone, as well as the committee ensemble of five models, outperforms all similar models. Next, we compare our results with six top networks overall, which contain complex layer types and design ideas, including generalized pooling functions, residual connections, and recurrent modules. Our results are competitive with these methods as well (Table 4). Finally, our method outperforms existing automated network design methods. MetaQNN obtains an error of $6 . 9 2 \%$ as compared to $2 1 . 2 \%$ reported by Bergstra et al. (2011) on CIFAR-10; and it obtains an error of $0 . 3 2 \%$ as compared to $7 . 9 \%$ reported by Verbancsics & Harguess (2013) on MNIST.
+
+Table 4: Error Rate Comparison with state-of-the-art methods with complex layer types. We report results for CIFAR-10 and CIFAR-100 with moderate data augmentation and results for MNIST and SVHN without any data augmentation.   
+
+<table><tr><td>Method</td><td>CIFAR-10</td><td>SVHN</td><td>MNIST</td><td>CIFAR-100</td></tr><tr><td>DropConnect (Wan et al., 2013)</td><td>9.32</td><td>1.94</td><td>0.57</td><td></td></tr><tr><td>DSN (Lee et al., 2015)</td><td>8.22</td><td>1.92</td><td>0.39</td><td>34.57</td></tr><tr><td>R-CNN (Liang&amp; Hu,2015)</td><td>7.72</td><td>1.77</td><td>0.31</td><td>31.75</td></tr><tr><td>MetaQNN (ensemble)</td><td>7.32</td><td>2.06</td><td>0.32</td><td>-</td></tr><tr><td>MetaQNN (top model)</td><td>6.92</td><td>2.28</td><td>0.44</td><td>27.14*</td></tr><tr><td>Resnet(110) (He et al.,2015)</td><td>6.61</td><td>1</td><td></td><td></td></tr><tr><td>Resnet(1001) (He et al.,2016)</td><td>4.62</td><td>=</td><td>=</td><td>22.71</td></tr><tr><td>ELU (Clevert et al., 2015)</td><td>6.55</td><td>=</td><td>=</td><td>24.28</td></tr><tr><td>Tree+Max-Avg (Lee et al.,2016)</td><td>6.05</td><td>1.69</td><td>0.31</td><td>32.37</td></tr></table>
+
+Table 5: Prediction Error for the top MetaQNN (CIFAR-10) model trained for other tasks. Finetuning refers to initializing training with the weights found for the optimal CIFAR-10 model.   
+
+<table><tr><td>Dataset</td><td>CIFAR-100</td><td>SVHN</td><td>MNIST</td></tr><tr><td>Training from scratch</td><td>27.14</td><td>2.48</td><td>0.80</td></tr><tr><td>Finetuning</td><td>34.93</td><td>4.00</td><td>0.81</td></tr><tr><td>State-of-the-art</td><td>24.28 (Clevert et al.,2015)</td><td>1.69 (Lee et al., 2016)</td><td>0.31 (Lee et al.,2016)</td></tr></table>
+
+The difference in validation error between the top 10 models for MNIST was very small, so we also created an ensemble with all 10 models. This ensemble achieved a test error of ${ \bf0 . 2 8 \% }$ —which beats the current state-of-the-art on MNIST without data augmentation.
+
+The best CIFAR-10 model performs $1 \%$ better than the four next best models, which is why the ensemble accuracy is lower than the best model’s accuracy. We posit that the CIFAR-10 MetaQNN did not have adequate exploration time given the larger state space compared to that of the SVHN experiment, causing it to not find more models with performance similar to the best model. Furthermore, the coarse training scheme could have been not as well suited for CIFAR-10 as it was for SVHN, causing some models to under perform.
+
+Transfer Learning Ability: Network designs such as VGGnet (Simonyan & Zisserman, 2014) can be adopted to solve a variety of computer vision problems. To check if the MetaQNN networks provide similar transfer learning ability, we use the best MetaQNN model on the CIFAR-10 dataset for training other computer vision tasks. The model performs well (Table 5) both when training from random initializations, and finetuning from existing weights.
+
+# 7 CONCLUDING REMARKS
+
+Neural networks are being used in an increasingly wide variety of domains, which calls for scalable solutions to produce problem-specific model architectures. We take a step towards this goal and show that a meta-modeling approach using reinforcement learning is able to generate tailored CNN designs for different image classification tasks. Our MetaQNN networks outperform previous metamodeling methods as well as hand-crafted networks which use the same types of layers.
+
+While we report results for image classification problems, our method could be applied to different problem settings, including supervised (e.g., classification, regression) and unsupervised (e.g., autoencoders). The MetaQNN method could also aid constraint-based network design, by optimizing parameters such as size, speed, and accuracy. For instance, one could add a threshold in the state-action space barring the agent from creating models larger than the desired limit. In addition, one could modify the reward function to penalize large models for constraining memory or penalize slow forward passes to incentivize quick inference.
+
+There are several future avenues for research in reinforcement learning-driven network design as well. In our current implementation, we use the same set of hyperparameters to train all network topologies during the $Q$ -learning phase and further finetune the hyperparameters for top models selected by the MetaQNN agent. However, our approach could be combined with hyperparameter optimization methods to further automate the network design process. Moreover, we constrict the state-action space using coarse, discrete bins to accelerate convergence. It would be possible to move to larger state-action spaces using methods for $Q$ -function approximation (Bertsekas, 2015; Mnih et al., 2015).
+
+# ACKNOWLEDGMENTS
+
+We thank Peter Downs for creating the project website and contributing to illustrations. We acknowledge Center for Bits and Atoms at MIT for their help with computing resources. Finally, we thank members of Camera Culture group at MIT Media Lab for their help and support.
+
+# REFERENCES
+
+Sander Adam, Lucian Busoniu, and Robert Babuska. Experience replay for real-time reinforcement learning control. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 42(2):201–212, 2012.
+
+James Bergstra, Daniel Yamins, and David D Cox. Making a science of model search: Hyperparameter optimization in hundreds of dimensions for vision architectures. ICML (1), 28:115–123, 2013.
+
+James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. NIPS, pp. 2546–2554, 2011.
+
+Dimitri P Bertsekas. Convex optimization algorithms. Athena Scientific Belmont, 2015.
+
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (ELUs). arXiv preprint arXiv:1511.07289, 2015.
+
+Tobias Domhan, Jost Tobias Springenberg, and Frank Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. IJCAI, 2015.
+
+Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. AISTATS, 9:249–256, 2010.
+
+Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron C Courville, and Yoshua Bengio. Maxout networks. ICML (3), 28:1319–1327, 2013.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016.
+
+Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014.
+
+Leslie Pack Kaelbling, Michael L Littman, and Andrew W Moore. Reinforcement learning: A survey. Journal of Artificial Intelligence Research, 4:237–285, 1996.
+
+Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014.
+
+Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015.
+
+Chen-Yu Lee, Saining Xie, Patrick Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. AISTATS, 2(3):6, 2015.
+
+Chen-Yu Lee, Patrick W Gallagher, and Zhuowen Tu. Generalizing pooling functions in convolutional neural networks: Mixed, gated, and tree. International Conference on Artificial Intelligence and Statistics, 2016.
+
+Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. JMLR, 17(39):1–40, 2016.
+
+Ming Liang and Xiaolin Hu. Recurrent convolutional neural network for object recognition. CVPR, pp. 3367–3375, 2015.
+
+Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015.
+
+Long-Ji Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine Learning, 8(3-4):293–321, 1992.
+
+Long-Ji Lin. Reinforcement learning for robots using neural networks. Technical report, DTIC Document, 1993.
+
+Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013.
+
+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.
+
+Nicolas Pinto, David Doukhan, James J DiCarlo, and David D Cox. A high-throughput screening approach to discovering good forms of biologically inspired visual representation. PLoS Computational Biology, 5(11):e1000579, 2009.
+
+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.
+
+Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In Advances in Neural Information Processing Systems 29, pp. 4053–4061. 2016.
+
+J David Schaffer, Darrell Whitley, and Larry J Eshelman. Combinations of genetic algorithms and neural networks: A survey of the state of the art. International Workshop on Combinations of Genetic Algorithms and Neural Networks, pp. 1–37, 1992.
+
+Pierre Sermanet, Soumith Chintala, and Yann LeCun. Convolutional neural networks applied to house numbers digit classification. ICPR, pp. 3288–3291, 2012.
+
+Pierre Sermanet, Koray Kavukcuoglu, Soumith Chintala, and Yann LeCun. Pedestrian detection with unsupervised multi-stage feature learning. CVPR, pp. 3626–3633, 2013.
+
+Bobak Shahriari, Kevin Swersky, Ziyu Wang, Ryan P Adams, and Nando de Freitas. Taking the human out of the loop: A review of bayesian optimization. Proceedings of the IEEE, 104(1): 148–175, 2016.
+
+David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016.
+
+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. NIPS, pp. 2951–2959, 2012.
+
+Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   
+Rupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015.   
+Kenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary Computation, 10(2):99–127, 2002.   
+Kevin Swersky, Jasper Snoek, and Ryan P Adams. Multi-task bayesian optimization. NIPS, pp. 2004–2012, 2013.   
+Phillip Verbancsics and Josh Harguess. Generative neuroevolution for deep learning. arXiv preprint arXiv:1312.5355, 2013.   
+Joannes Vermorel and Mehryar Mohri. Multi-armed bandit algorithms and empirical evaluation. European Conference on Machine Learning, pp. 437–448, 2005.   
+Li Wan, Matthew Zeiler, Sixin Zhang, Yann L Cun, and Rob Fergus. Regularization of neural networks using dropconnect. ICML, pp. 1058–1066, 2013.   
+Christopher John Cornish Hellaby Watkins. Learning from delayed rewards. PhD thesis, University of Cambridge, England, 1989.
+
+# APPENDIX
+
+# A ALGORITHM
+
+We first describe the main components of the MetaQNN algorithm. Algorithm 1 shows the main loop, where the parameter $M$ would determine how many models to run for a given $\epsilon$ and the parameter $K$ would determine how many times to sample the replay database to update $Q$ -values on each iteration. The function TRAIN refers to training the specified network and returns a validation accuracy. Algorithm 2 details the method for sampling a new network using the $\epsilon$ -greedy strategy, where we assume we have a function TRANSITION that returns the next state given a state and action. Finally, Algorithm 3 implements the $Q$ -value update detailed in Equation 3, with discounting factor set to 1, for an entire state sequence in temporally reversed order.
+
+# Algorithm 1 $Q$ -learning For CNN Topologies
+
+Initialize: replay memory $ [ ]$ $Q  \{ ( s , u ) \forall s \in S , u \in \mathcal { U } ( s ) \ : \ 0 . 5 \}$   
+for episode $= 1$ to $M$ do $S$ , U ← SAMPLE NEW NETWORK(, Q) accuracy $ \mathrm { T R A I N } ( S )$ replay memory.append((S, U, accuracy)) for memory $= 1$ to $K$ do $S _ { S A M P L E }$ , $U _ { S A M P L E }$ , accuracySAMP LE Uniform{replay memory} $Q $ UPDATE Q VALUES( $Q$ , $S _ { S A M P L E }$ , $U _ { S A M P L E }$ , accuracySAMP LE) end for   
+end for
+
+# Algorithm 2 SAMPLE NEW NETWORK(, Q)
+
+Initialize: state sequence $S = [ s _ { \mathrm { S T A R T } } ]$ action sequence $U = [ ]$   
+while $U [ - 1 ] \neq$ terminate do $\alpha \sim \mathrm { U n i f o r m } [ 0 , 1 )$ if $\alpha > \epsilon$ then u = argmaxu∈U(S[−1]) Q[(S[−1], u)] s0 = TRANSITION(S[−1], u) else u ∼ Uniform{U(S[−1])} s0 = TRANSITION(S[−1], u) end if U.append $( u )$ if $u : =$ terminate then S.append $\left( s ^ { \prime } \right)$ end if   
+end while   
+return S, U
+
+<table><tr><td>Algorithm3UPDATE_Q_VALUES(Q,S,U,accuracy)</td></tr><tr><td>Q[S[-1],U[-1]] = (1- α)Q[S[-1],U[-1] + α·accuracy</td></tr><tr><td>fori= length(S) - 2 to 0 do</td></tr><tr><td>Q[S[i],U[i]] = (1 -α)Q[S[i], U[i]] + α maxu∈u(S[i+1]) Q[S[i +1],u]</td></tr><tr><td>end for return Q</td></tr></table>
+
+# B REPRESENTATION SIZE BINNING
+
+As mentioned in Section 4.1 of the main text, we introduce a parameter called representation size to prohibit the agent from taking actions that can reduce the intermediate signal representation to a size that is too small for further processing. However, this process leads to uncertainties in state transitions, as illustrated in Figure A1, which is handled by the standard $Q$ -learning formulation.
+
+![](images/bbf152a1215e64fdb34aeb4684b1733d98942af3e1032056d78615c9c7da28af.jpg)  
+Figure A1: Representation size binning: In this figure, we show three example state transitions. The true representation size ( $R$ -size) parameter is included in the figure to show the true underlying state. Assuming there are two $R$ -size bins, $R$ -size $\mathrm { B i n _ { 1 } }$ : $[ 8 , \infty )$ and $R$ -size $\mathrm { B i n _ { 2 } }$ : (0, 7], Figure A1a shows the case where the initial state is in $R$ -size $\mathrm { B i n _ { 1 } }$ and true representation size is 18. After the agent chooses to pool with a $2 \times 2$ filter with stride 2, the true representation size reduces to 9 but the $R$ -size bin does not change. In Figure A1b, the same $2 \times 2$ pooling layer with stride 2 reduces the actual representation size of 14 to 7, but the bin changes to $R$ -size $\mathrm { B i n _ { 2 } }$ . Therefore, in figures A1a and A1b, the agent ends up in different final states, despite originating in the same initial state and choosing the same action. Figure A1c shows that in our state-action space, when the agent takes an action that reduces the representation size, it will have uncertainty in which state it will transition to.
+
+# C MNIST EXPERIMENT
+
+We noticed that the final MNIST models were prone to overfitting, so we increased dropout and did a small grid search for the weight regularization parameter. For both tuning and final training, we warmed the model with the learned weights from after the first epoch of initial training. The final models and solvers can be found on our project website https://bowenbaker.github.io/metaqnn/. Figure A2 shows the $Q$ -Learning performance for the MNIST experiment.
+
+# D FURTHER ANALYSIS OF $Q$ -LEARNING
+
+Figure 3 of the main text and Figure A2 show that as the agent begins to exploit, it improves in architecture selection. It is also informative to look at the distribution of models chosen at each $\epsilon$ . Figure A4 gives further insight into the performance achieved at each $\epsilon$ for both experiments.
+
+# D.1 $Q$ -LEARNING STABILITY
+
+Because the $Q$ -learning agent explores via a random or semi-random distribution, it is natural to ask whether the agent can consistently improve architecture performance. While the success of the three independent experiments described in the main text allude to stability, here we present further evidence. We conduct 10 independent runs of the $Q$ -learning procedure on $10 \%$ of the SVHN dataset (which corresponds to $\sim 7 { , } 0 0 0$ training examples). We use a smaller dataset to reduce the computation time of each independent run to 10GPU-days, as opposed to the 100GPU-days it would take on the full dataset. As can be seen in Figure A3, the $Q$ -learning procedure with the exploration schedule detailed in Table 2 is fairly stable. The standard deviation at $\epsilon = 1$ is notably smaller than at other stages, which we attribute to the large difference in number of samples at each stage.
+
+![](images/1040a48db3c9107445d63faf705edb1033b4dc791f36b6e6a2203c2e49609895.jpg)  
+Figure A2: MNIST $Q$ -Learning Performance. The blue line shows a rolling mean of model accuracy versus iteration, where in each iteration of the algorithm the agent is sampling a model. Each bar (in light blue) marks the average accuracy over all models that were sampled during the exploration phase with the labeled $\epsilon$ . As $\epsilon$ decreases, the average accuracy goes up, demonstrating that the agent learns to select better-performing CNN architectures.
+
+![](images/a64860a6aa693382887f15593297e5ca583d08775c931f3f68c8338f77f67885.jpg)  
+Figure A3: Figure A3a shows the mean model accuracy and standard deviation at each $\epsilon$ over 10 independent runs of the $Q$ -learning procedure on $10 \%$ of the SVHN dataset. Figure A3b shows the mean model accuracy at each $\epsilon$ for each independent experiment. Despite some variance due to a randomized exploration strategy, each independent run successfully improves architecture performance.
+
+Furthermore, the best model found during each run had remarkably similar performance with a mean accuracy of $8 8 . 2 5 \%$ and standard deviation of $0 . 5 8 \%$ , which shows that each run successfully found at least one very high performing model. Note that we did not use an extended training schedule to improve performance in this experiment.
+
+# D.2 $Q$ -VALUE ANALYSIS
+
+We now analyze the actual $Q$ -values generated by the agent during the training process. The learning agent iteratively updates the $Q$ -values of each path during the $\epsilon$ -greedy exploration. Each $Q$ -value is initialized at 0.5. After the $\epsilon$ -schedule is complete, we can analyze the final $Q$ -value associated with each path to gain insights into the layer selection process. In the left column of Figure A5, we plot the average $Q$ -value for each layer type at different layer depths (for both SVHN and CIFAR10) datasets. Roughly speaking, a higher $Q$ -value associated with a layer type indicates a higher probability that the agent will pick that layer type. In Figure A5, we observe that, while the average $Q$ -value is higher for convolution and pooling layers at lower layer depths, the $Q$ -values for fullyconnected and termination layers (softmax and global average pooling) increase as we go deeper into the network. This observation matches with traditional network designs.
+
+We can also plot the average $Q$ -values associated with different layer parameters for further analysis. In the right column of Figure A5, we plot the average $Q$ -values for convolution layers with receptive field sizes 1, 3, and 5 at different layer depths. The plots show that layers with receptive field size of 5 have a higher $Q$ -value as compared to sizes 1 and 3 as we go deeper into the networks. This indicates that it might be beneficial to use larger receptive field sizes in deeper networks.
+
+In summary, the $Q$ -learning method enables us to perform analysis on the relative benefits of different design parameters of our state space, and possibly gain insights for new CNN designs.
+
+# E TOP TOPOLOGIES SELECTED BY ALGORITHM
+
+In Tables A1 through A3, we present the top five model architectures selected with Q-learning for each dataset, along with their prediction error reported on the test set, and their total number of parameters. To download the Caffe solver and prototext files, please visit https://bowenbaker.github.io/metaqnn/.
+
+Table A1: Top 5 model architectures: CIFAR-10.   
+
+<table><tr><td rowspan=1 colspan=1>Model Architecture</td><td rowspan=1 colspan=1>Test Error (%)</td><td rowspan=1 colspan=1>#Params (10)</td></tr><tr><td rowspan=1 colspan=1>[C(512,5,1), C(256,3,1), C(256,5,1), C(256,3,1),P(5,3),C(512,3,1),C(512,5,1), P(2,2), SM(10)]</td><td rowspan=1 colspan=1>6.92</td><td rowspan=1 colspan=1>11.18</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1),C(512,3,1),C(64,1,1), C(128,3,1),P(2,2),C(256,3,1),P(2,2), C(512,3,1),P(3,2),,SM(10)]</td><td rowspan=1 colspan=1>8.78</td><td rowspan=1 colspan=1>2.17</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1),C(128,1,1),C(512,5,1),P(2,2),C(128,3,1),P(2,2),C(64,3,1),C(64,5,1), S(10)]</td><td rowspan=1 colspan=1>8.88</td><td rowspan=1 colspan=1>2.42</td></tr><tr><td rowspan=1 colspan=1>[C(256,3,1),C(256,3,1),P(5,3),C(256,1,1),C(128,3,1),P(2,2),C(128,3,1), ,SM(10)]</td><td rowspan=1 colspan=1>9.24</td><td rowspan=1 colspan=1>1.10</td></tr><tr><td rowspan=1 colspan=1>[C(128,5,1),C(512,3,1),P(2,2),C(128,1,1),C(128,5,1),P(3,2),C(512,3,1), SM(10)]</td><td rowspan=1 colspan=1>11.63</td><td rowspan=1 colspan=1>1.66</td></tr></table>
+
+<table><tr><td rowspan=1 colspan=1>Model Architecture</td><td rowspan=1 colspan=1>Test Error (%)</td><td rowspan=1 colspan=1>#Params (106)</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1), P(2,2),C(64,5,1),C(512,5,1),C(256,3,1),C(512,3,1),P(2,2), C(512,3,1),C(256,5,1),C(256,3,1),C(128,5,1),C(64,3,1),SM(10)]</td><td rowspan=1 colspan=1>2.24</td><td rowspan=1 colspan=1>9.81</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1), C(256,5,1)，C(128,5,1), P(2,2)，C(256,5,1),C(256,1,1),C(256,3,1), C(256,3,1), C(256,5,1), C(512,5,1), C(256,3,1),C(128,3,1), SM(10)]</td><td rowspan=1 colspan=1>2.28</td><td rowspan=1 colspan=1>10.38</td></tr><tr><td rowspan=1 colspan=1>[C(128,5,1)， C(128,3,1),C(64,5,1),P(5,3),C(128,3,1),C(512,5,1),C(256,5,1), C(128,5,1), C(128,5,1),,C(128,3,1), SM(10)]</td><td rowspan=1 colspan=1>2.32</td><td rowspan=1 colspan=1>6.83</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1),C(256,5,1),C(128,5,1),C(256,3,1),C(256,5,1), P(2,2),C(128,1,1),C(512,3,1),C(256,5,1),P(2,2),C(64,5,1),C(64,1,1),SM(10)]</td><td rowspan=1 colspan=1>2.35</td><td rowspan=1 colspan=1>6.99</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1), C(256,5,1), C(128,5,1), C(256,5,1), C(256,5,1),C(256,1,1), P(3,2), C(128,1,1),C(256,5,1),C(512,5,1),C(256,3,1),C(128,3,1), SM(10)]</td><td rowspan=1 colspan=1>2.36</td><td rowspan=1 colspan=1>10.05</td></tr></table>
+
+Table A2: Top 5 model architectures: SVHN. Note that we do not report the best accuracy on test set from the above models in Tables 3 and 4 from the main text. This is because the model that achieved $2 . 2 8 \%$ on the test set performed the best on the validation set.
+
+<table><tr><td rowspan=1 colspan=1>Model Architecture</td><td rowspan=1 colspan=1>Test Error (%)</td><td rowspan=1 colspan=1>#Params (10)</td></tr><tr><td rowspan=1 colspan=1>[C(64,1,1)，C(256,3,1)，P(2,2)，C(512,3,1), C(256,1,1), P(5,3),C(256,3,1), C(512,3,1),FC(512), SM(10)]</td><td rowspan=1 colspan=1>0.35</td><td rowspan=1 colspan=1>5.59</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1), C(64,1,1),C(64,3,1), C(64,5,1), P(2,2), C(128,3,1), P(3,2),C(512,3,1), FC(512),FC(128), S(10)]</td><td rowspan=1 colspan=1>0.38</td><td rowspan=1 colspan=1>7.43</td></tr><tr><td rowspan=1 colspan=1>[C(512,1,1), C(128,3,1), C(128,5,1), C(64,1,1), C(256,5,1), C(64,1,1),P(5,3), C(512,1,1), C(512,3,1), C(256,3,1), C(256,5,1), C(256,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.40</td><td rowspan=1 colspan=1>8.28</td></tr><tr><td rowspan=1 colspan=1>[C(64,3,1), C(128,3,1), C(512,1,1), C(256,1,1), C(256,5,1), C(128,3,1),P(5,3), C(512,1,1), C(512,3,1), C(128,5,1), SM(10)]</td><td rowspan=1 colspan=1>0.41</td><td rowspan=1 colspan=1>6.27</td></tr><tr><td rowspan=1 colspan=1>[C(64,3,1),C(128,1,1),P(2,2)， C(256,3,1),C(128,5,1),C(64,1,1),C(512,5,1), C(128,5,1), C(64,1,1), C(512,5,1), C(256,5,1), C(64,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.43</td><td rowspan=1 colspan=1>8.10</td></tr><tr><td rowspan=1 colspan=1>[C(64,1,1),C(256,5,1),,C(256,5,1),C(512,1,1)，C(64,3,1),P(5,3),C(256,5,1), C(256,5,1), C(512,5,1), C(64,1,1), C(128,5,1), C(512,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.44</td><td rowspan=1 colspan=1>9.67</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1)， C(512,3,1)，P(2,2)， C(256,3,1),，C(128,5,1),C(64,1,1),C(64,5,1), C(512,5,1), GAP(10), SM(10)]</td><td rowspan=1 colspan=1>0.44</td><td rowspan=1 colspan=1>3.52</td></tr><tr><td rowspan=1 colspan=1>[C(256,3,1), C(256,5,1), C(512,3,1), C(256,5,1)，C(512,1,1),P(5,3),C(256,3,1), C(64,3,1), C(256,5,1), C(512,3,1), C(128,5,1), C(512,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.46</td><td rowspan=1 colspan=1>12.42</td></tr><tr><td rowspan=1 colspan=1>[C(512,5,1), C(128,5,1), C(128,5,1), C(128,3,1), C(256,3,1),C(512,5,1), C(256,3,1), C(128,3,1), S(10)]</td><td rowspan=1 colspan=1>0.55</td><td rowspan=1 colspan=1>7.25</td></tr><tr><td rowspan=1 colspan=1>[C(64,5,1),C(512,5,1),P(3,2)，C(256,5,1),C(256,3,1),C(256,3,1),C(128,1,1),C(256,3,1), C(256,5,1), C(64,1,1), C(256,3,1),C(64,3,1),SM(10)]</td><td rowspan=1 colspan=1>0.56</td><td rowspan=1 colspan=1>7.55</td></tr></table>
+
+Table A3: Top 10 model architectures: MNIST. We report the top 10 models for MNIST because we included all 10 in our final ensemble. Note that we do not report the best accuracy on test set from the above models in Tables 3 and 4 from the main text. This is because the model that achieved $0 . 4 4 \%$ on the test set performed the best on the validation set.
+
+![](images/fd32a7a7238161bd217f837e7aa678dfc6a19faca503b359140d345a8d6ea0ab.jpg)  
+Figure A4: Accuracy Distribution versus $\epsilon$ : Figures A4a, A4c, and A4e show the accuracy distribution for each $\epsilon$ for the SVHN, CIFAR-10, and MNIST experiments, respectively. Figures A4b, A4d, and A4f show the accuracy distributions for the initial $\epsilon = 1$ and the final $\epsilon = 0 . 1$ . One can see that the accuracy distribution becomes much more peaked in the high accuracy ranges at small $\epsilon$ for each experiment.
+
+![](images/7533dcaeb55b1d1b05fd06f4deb470699d4d0219efe173f88397cbc8c105105c.jpg)  
+Figure A5: Average $Q$ -Value versus Layer Depth for different layer types are shown in the left column. Average $Q$ -Value versus Layer Depth for different receptive field sizes of the convolution layer are shown in the right column.

parse/train/S1c2cvqee/S1c2cvqee_content_list.json

@@ -0,0 +1,1643 @@
+[
+    {
+        "type": "text",
+        "text": "DESIGNING NEURAL NETWORK ARCHITECTURES USING REINFORCEMENT LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            771,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Bowen Baker, Otkrist Gupta, Nikhil Naik & Ramesh Raskar ",
+        "bbox": [
+            183,
+            170,
+            606,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Media Laboratory   \nMassachusetts Institute of Technology   \nCambridge MA 02139, USA   \n{bowen, otkrist, naik, raskar}@mit.edu ",
+        "bbox": [
+            184,
+            185,
+            553,
+            239
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            276,
+            544,
+            291
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "At present, designing convolutional neural network (CNN) architectures requires both human expertise and labor. New architectures are handcrafted by careful experimentation or modified from a handful of existing networks. We introduce MetaQNN, a meta-modeling algorithm based on reinforcement learning to automatically generate high-performing CNN architectures for a given learning task. The learning agent is trained to sequentially choose CNN layers using $Q$ - learning with an $\\epsilon$ -greedy exploration strategy and experience replay. The agent explores a large but finite space of possible architectures and iteratively discovers designs with improved performance on the learning task. On image classification benchmarks, the agent-designed networks (consisting of only standard convolution, pooling, and fully-connected layers) beat existing networks designed with the same layer types and are competitive against the state-of-the-art methods that use more complex layer types. We also outperform existing meta-modeling approaches for network design on image classification tasks. ",
+        "bbox": [
+            233,
+            306,
+            764,
+            500
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            523,
+            336,
+            539
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep convolutional neural networks (CNNs) have seen great success in the past few years on a variety of machine learning problems (LeCun et al., 2015). A typical CNN architecture consists of several convolution, pooling, and fully connected layers. While constructing a CNN, a network designer has to make numerous design choices: the number of layers of each type, the ordering of layers, and the hyperparameters for each type of layer, e.g., the receptive field size, stride, and number of receptive fields for a convolution layer. The number of possible choices makes the design space of CNN architectures extremely large and hence, infeasible for an exhaustive manual search. While there has been some work (Pinto et al., 2009; Bergstra et al., 2013; Domhan et al., 2015) on automated or computer-aided neural network design, new CNN architectures or network design elements are still primarily developed by researchers using new theoretical insights or intuition gained from experimentation. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            707
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we seek to automate the process of CNN architecture selection through a metamodeling procedure based on reinforcement learning. We construct a novel $Q$ -learning agent whose goal is to discover CNN architectures that perform well on a given machine learning task with no human intervention. The learning agent is given the task of sequentially picking layers of a CNN model. By discretizing and limiting the layer parameters to choose from, the agent is left with a finite but large space of model architectures to search from. The agent learns through random exploration and slowly begins to exploit its findings to select higher performing models using the $\\epsilon \\cdot$ - greedy strategy (Mnih et al., 2015). The agent receives the validation accuracy on the given machine learning task as the reward for selecting an architecture. We expedite the learning process through repeated memory sampling using experience replay (Lin, 1993). We refer to this $Q$ -learning based meta-modeling method as MetaQNN, which is summarized in Figure 1.1 ",
+        "bbox": [
+            174,
+            713,
+            825,
+            866
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We conduct experiments with a space of model architectures consisting of only standard convolution, pooling, and fully connected layers using three standard image classification datasets: CIFAR-10, ",
+        "bbox": [
+            178,
+            875,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/46d5c58f33c694a26ef479826deb91e729210b90ab747d2d227eb608e4fdeb87.jpg",
+        "image_caption": [
+            "Figure 1: Designing CNN Architectures with $Q$ -learning: The agent begins by sampling a Convolutional Neural Network (CNN) topology conditioned on a predefined behavior distribution and the agent’s prior experience (left block). That CNN topology is then trained on a specific task; the topology description and performance, e.g. validation accuracy, are then stored in the agent’s memory (middle block). Finally, the agent uses its memories to learn about the space of CNN topologies through $Q$ -learning (right block). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            184,
+            104,
+            795,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "SVHN, and MNIST. The learning agent discovers CNN architectures that beat all existing networks designed only with the same layer types (e.g., Springenberg et al. (2014); Srivastava et al. (2015)). In addition, their performance is competitive against network designs that include complex layer types and training procedures (e.g., Clevert et al. (2015); Lee et al. (2016)). Finally, the MetaQNN selected models comfortably outperform previous automated network design methods (Stanley & Miikkulainen, 2002; Bergstra et al., 2013). The top network designs discovered by the agent on one dataset are also competitive when trained on other datasets, indicating that they are suited for transfer learning tasks. Moreover, we can generate not just one, but several varied, well-performing network designs, which can be ensembled to further boost the prediction performance. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            477
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            501,
+            344,
+            516
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Designing neural network architectures: Research on automating neural network design goes back to the 1980s when genetic algorithm-based approaches were proposed to find both architectures and weights (Schaffer et al., 1992). However, to the best of our knowledge, networks designed with genetic algorithms, such as those generated with the NEAT algorithm (Stanley & Miikkulainen, 2002), have been unable to match the performance of hand-crafted networks on standard benchmarks (Verbancsics & Harguess, 2013). Other biologically inspired ideas have also been explored; motivated by screening methods in genetics, Pinto et al. (2009) proposed a high-throughput network selection approach where they randomly sample thousands of architectures and choose promising ones for further training. In recent work, Saxena & Verbeek (2016) propose to sidestep the architecture selection process through densely connected networks of layers, which come closer to the performance of hand-crafted networks. ",
+        "bbox": [
+            174,
+            535,
+            825,
+            686
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Bayesian optimization has also been used (Shahriari et al., 2016) for automatic selection of network architectures (Bergstra et al., 2013; Domhan et al., 2015) and hyperparameters (Snoek et al., 2012; Swersky et al., 2013). Notably, Bergstra et al. (2013) proposed a meta-modeling approach based on Tree of Parzen Estimators (TPE) (Bergstra et al., 2011) to choose both the type of layers and hyperparameters of feed-forward networks; however, they fail to match the performance of handcrafted networks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            777
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Reinforcement Learning: Recently there has been much work at the intersection of reinforcement learning and deep learning. For instance, methods using CNNs to approximate the $Q$ -learning utility function (Watkins, 1989) have been successful in game-playing agents (Mnih et al., 2015; Silver et al., 2016) and robotic control (Lillicrap et al., 2015; Levine et al., 2016). These methods rely on phases of exploration, where the agent tries to learn about its environment through sampling, and exploitation, where the agent uses what it learned about the environment to find better paths. In traditional reinforcement learning settings, over-exploration can lead to slow convergence times, yet over-exploitation can lead to convergence to local minima (Kaelbling et al., 1996). However, in the case of large or continuous state spaces, the $\\epsilon$ -greedy strategy of learning has been empirically shown to converge (Vermorel & Mohri, 2005). Finally, when the state space is large or exploration is costly, the experience replay technique (Lin, 1993) has proved useful in experimental settings (Adam et al., 2012; Mnih et al., 2015). We incorporate these techniques— $Q$ -learning, the $\\epsilon$ -greedy strategy and experience replay—in our algorithm design. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 BACKGROUND ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            166,
+            326,
+            183
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our method relies on $Q$ -learning, a type of reinforcement learning. We now summarize the theoretical formulation of $Q$ -learning, as adopted to our problem. Consider the task of teaching an agent to find optimal paths as a Markov Decision Process (MDP) in a finite-horizon environment. Constraining the environment to be finite-horizon ensures that the agent will deterministically terminate in a finite number of time steps. In addition, we restrict the environment to have a discrete and finite state space $s$ as well as action space $\\mathcal { U }$ . For any state $s _ { i } \\in S$ , there is a finite set of actions, $\\mathcal { U } ( s _ { i } ) \\subseteq \\mathcal { U }$ , that the agent can choose from. In an environment with stochastic transitions, an agent in state $s _ { i }$ taking some action $u \\in \\mathcal { U } ( s _ { i } )$ will transition to state $s _ { j }$ with probability $p _ { s ^ { \\prime } | s , u } ( s _ { j } | s _ { i } , u )$ , which may be unknown to the agent. At each time step $t$ , the agent is given a reward $r _ { t }$ , dependent on the transition from state $s$ to $s ^ { \\prime }$ and action $u$ . $r _ { t }$ may also be stochastic according to a distribution $p _ { r | s ^ { \\prime } , s , u }$ . The agent’s goal is to maximize the total expected reward over all possible trajectories, i.e., $\\operatorname* { m i n } _ { \\mathbf { \\zeta } } { } _ { T _ { i } \\in \\mathcal { T } } { \\cal R } _ { T _ { i } }$ , where the total expected reward for a trajectory $\\mathcal { T } _ { i }$ is ",
+        "bbox": [
+            173,
+            198,
+            825,
+            364
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5927b27f356ba42e91e4a613fc362ee76bca291b5db7b09cc114b42b0bfaaa10.jpg",
+        "text": "$$\n\\begin{array} { r } { R _ { \\mathcal { T } _ { i } } = \\sum _ { ( s , u , s ^ { \\prime } ) \\in \\mathcal { T } _ { i } } \\mathbb { E } _ { r | s , u , s ^ { \\prime } } [ r | s , u , s ^ { \\prime } ] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            369,
+            372,
+            629,
+            392
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Though we limit the agent to a finite state and action space, there are still a combinatorially large number of trajectories, which motivates the use of reinforcement learning. We define the maximization problem recursively in terms of subproblems as follows. For any state $s _ { i } \\in S$ and subsequent action $u \\in \\mathcal { U } ( s _ { i } )$ , we define the maximum total expected reward to be $Q ^ { * } ( s _ { i } , u )$ . $Q ^ { * } ( \\cdot )$ is known as the action-value function and individual $Q ^ { * } ( s _ { i } , u )$ are know as $Q$ -values. The recursive maximization equation, which is known as Bellman’s Equation, can be written as ",
+        "bbox": [
+            173,
+            397,
+            825,
+            481
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef0e94ac1db4e47b4f8c492f0a1cdc6e797ddb4fe993c8e935c435b38a1c1598.jpg",
+        "text": "$$\n\\begin{array} { r } { Q ^ { * } ( s _ { i } , u ) = \\mathbb { E } _ { s _ { j } \\mid s _ { i } , u } \\left[ \\mathbb { E } _ { r \\mid s _ { i } , u , s _ { j } } [ r \\mid s _ { i } , u , s _ { j } ] + \\gamma \\operatorname* { m a x } _ { u ^ { \\prime } \\in \\mathcal { U } ( s _ { j } ) } Q ^ { * } ( s _ { j } , u ^ { \\prime } ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            258,
+            488,
+            740,
+            507
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In many cases, it is impossible to analytically solve Bellman’s Equation (Bertsekas, 2015), but it can be formulated as an iterative update ",
+        "bbox": [
+            176,
+            512,
+            823,
+            541
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11cf16f74b6756b632c5c05b824dfd97ed13031d9f2a39e03093838d14986339.jpg",
+        "text": "$$\n\\begin{array} { r } { Q _ { t + 1 } ( s _ { i } , u ) = ( 1 - \\alpha ) Q _ { t } ( s _ { i } , u ) + \\alpha \\left[ r _ { t } + \\gamma \\operatorname* { m a x } _ { u ^ { \\prime } \\in \\mathcal { U } ( s _ { j } ) } Q _ { t } ( s _ { j } , u ^ { \\prime } ) \\right] . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            248,
+            546,
+            717,
+            566
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Equation 3 is the simplest form of $Q$ -learning proposed by Watkins (1989). For well formulated problems, $\\begin{array} { r } { \\operatorname* { l i m } _ { t \\to \\infty } \\bar { Q _ { t } } ( s , u ) = Q ^ { * } ( s , u ) } \\end{array}$ , as long as each transition is sampled infinitely many times (Bertsekas, 2015). The update equation has two parameters: (i) $\\alpha$ is a $Q$ -learning rate which determines the weight given to new information over old information, and (ii) $\\gamma$ is the discount factor which determines the weight given to short-term rewards over future rewards. The $Q$ -learning algorithm is model-free, in that the learning agent can solve the task without ever explicitly constructing an estimate of environmental dynamics. In addition, $Q$ -learning is off policy, meaning it can learn about optimal policies while exploring via a non-optimal behavioral distribution, i.e. the distribution by which the agent explores its environment. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            698
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We choose the behavior distribution using an $\\epsilon$ -greedy strategy (Mnih et al., 2015). With this strategy, a random action is taken with probability $\\epsilon$ and the greedy action, $\\begin{array} { r } { \\operatorname* { m a x } _ { u \\in \\mathcal { U } ( s _ { i } ) } Q _ { t } \\mathopen { } \\mathclose \\bgroup \\left( s _ { i } , u \\aftergroup \\egroup \\right) } \\end{array}$ , is chosen with probability $1 - \\epsilon$ . We anneal $\\epsilon$ from $1  0$ such that the agent begins in an exploration phase and slowly starts moving towards the exploitation phase. In addition, when the exploration cost is large (which is true for our problem setting), it is beneficial to use the experience replay technique for faster convergence (Lin, 1992). In experience replay, the learning agent is provided with a memory of its past explored paths and rewards. At a given interval, the agent samples from the memory and updates its $Q$ -values via Equation 3. ",
+        "bbox": [
+            173,
+            704,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "4 DESIGNING NEURAL NETWORK ARCHITECTURES WITH $Q$ -LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            835,
+            784,
+            852
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We consider the task of training a learning agent to sequentially choose neural network layers. Figure 2 shows feasible state and action spaces (a) and a potential trajectory the agent may take along with the CNN architecture defined by this trajectory (b). We model the layer selection process as a Markov Decision Process with the assumption that a well-performing layer in one network should also perform well in another network. We make this assumption based on the hierarchical nature of the feature representations learned by neural networks with many hidden layers (LeCun et al., 2015). The agent sequentially selects layers via the $\\epsilon$ -greedy strategy until it reaches a termination state. The CNN architecture defined by the agent’s path is trained on the chosen learning problem, and the agent is given a reward equal to the validation accuracy. The validation accuracy and architecture description are stored in a replay memory, and experiences are sampled periodically from the replay memory to update $Q$ -values via Equation 3. The agent follows an $\\epsilon$ schedule which determines its shift from exploration to exploitation. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/dee80030fc5fc1b6ad35a44d75d773edc835d64b20e4221813dc684b9dea8980.jpg",
+        "image_caption": [
+            "Figure 2: Markov Decision Process for CNN Architecture Generation: Figure 2(a) shows the full state and action space. In this illustration, actions are shown to be deterministic for clarity, but they are stochastic in experiments. $C ( n , f , l )$ denotes a convolutional layer with $n$ filters, receptive field size $f$ , and stride l. $P ( f , l )$ denotes a pooling layer with receptive field size $f$ and stride l. $G$ denotes a termination state (Softmax/Global Average Pooling). Figure 2(b) shows a path the agent may choose, highlighted in green, and the corresponding CNN topology. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            99,
+            826,
+            222
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            369,
+            825,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Our method requires three main design choices: (i) reducing CNN layer definitions to simple state tuples, (ii) defining a set of actions the agent may take, i.e., the set of layers the agent may pick next given its current state, and (iii) balancing the size of the state-action space—and correspondingly, the model capacity—with the amount of exploration needed by the agent to converge. We now describe the design choices and the learning process in detail. ",
+        "bbox": [
+            174,
+            488,
+            825,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4.1 THE STATE SPACE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            602,
+            341,
+            616
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each state is defined as a tuple of all relevant layer parameters. We allow five different types of layers: convolution (C), pooling (P), fully connected (FC), global average pooling (GAP), and softmax (SM), though the general method is not limited to this set. Table 1 shows the relevant parameters for each layer type and also the discretization we chose for each parameter. Each layer has a parameter layer depth (shown as Layer $1 , 2 , \\ldots$ in Figure 2). Adding layer depth to the state space allows us to constrict the action space such that the state-action graph is directed and acyclic (DAG) and also allows us to specify a maximum number of layers the agent may select before terminating. ",
+        "bbox": [
+            174,
+            638,
+            825,
+            736
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each layer type also has a parameter called representation size $R$ -size). Convolutional nets progressively compress the representation of the original signal through pooling and convolution. The presence of these layers in our state space may lead the agent on a trajectory where the intermediate signal representation gets reduced to a size that is too small for further processing. For example, five $2 \\times 2$ pooling layers each with stride 2 will reduce an image of initial size $3 2 \\times 3 2$ to size $1 \\times 1$ . At this stage, further pooling, or convolution with receptive field size greater than 1, would be meaningless and degenerate. To avoid such scenarios, we add the $R$ -size parameter to the state tuple $s$ , which allows us to restrict actions from states with $R$ -size $n$ to those that have a receptive field size less than or equal to $n$ . To further constrict the state space, we chose to bin the representation sizes into three discrete buckets. However, binning adds uncertainty to the state transitions: depending on the true underlying representation size, a pooling layer may or may not change the $R$ -size bin. As a result, the action of pooling can lead to two different states, which we model as stochasticity in state transitions. Please see Figure A1 in appendix for an illustrated example. ",
+        "bbox": [
+            174,
+            743,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/fb543ef1fbe7f8639d321846cd82d1fd9ded4647a7073b64fe76386290ecd552.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 1: Experimental State Space. For each layer type, we list the relevant parameters and the values each parameter is allowed to take. "
+        ],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Layer Type</td><td rowspan=1 colspan=1>LayerParameters</td><td rowspan=1 colspan=1>ParameterValues</td></tr><tr><td rowspan=1 colspan=1>Convolution (C)</td><td rowspan=1 colspan=1>i~Layer depthf~Receptive field sizel~Strided ~ # receptive fieldsn ~ Representation size</td><td rowspan=1 colspan=1>&lt;12Square. ∈ {1,3,5}Square.Always equal to 1∈{64,128,256,512}∈{(,8],(8,4],（4,1]}</td></tr><tr><td rowspan=1 colspan=1>Pooling (P)</td><td rowspan=1 colspan=1>i~Layer depth(f,l)~ (Receptive field size, Strides)n ~ Representation size</td><td rowspan=1 colspan=1>&lt;12Square.∈{(5,3),(3,2),(2,2)}∈{(∞,8],(8,4] and (4,1]}</td></tr><tr><td rowspan=1 colspan=1>Fully Connected (FC)</td><td rowspan=1 colspan=1>i~Layerdepthn ~ # consecutive FC layersd ~# neurons</td><td rowspan=1 colspan=1>&lt;12&lt;3∈ {512,256,128}</td></tr><tr><td rowspan=1 colspan=1>Termination State</td><td rowspan=1 colspan=1>S~Previous Statet~Type</td><td rowspan=1 colspan=1>Global Avg.Pooling/Softmax</td></tr></table>",
+        "bbox": [
+            199,
+            101,
+            799,
+            281
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.2 THE ACTION SPACE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            348,
+            352,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We restrict the agent from taking certain actions to both limit the state-action space and make learning tractable. First, we allow the agent to terminate a path at any point, i.e. it may choose a termination state from any non-termination state. In addition, we only allow transitions for a state with layer depth $i$ to a state with layer depth $i + 1$ , which ensures that there are no loops in the graph. This constraint ensures that the state-action graph is always a DAG. Any state at the maximum layer depth, as prescribed in Table 1, may only transition to a termination layer. ",
+        "bbox": [
+            174,
+            375,
+            825,
+            458
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Next, we limit the number of fully connected (FC) layers to be at maximum two, because a large number of FC layers can lead to too may learnable parameters. The agent at a state with type FC may transition to another state with type FC if and only if the number of consecutive FC states is less than the maximum allowed. Furthermore, a state $s$ of type FC with number of neurons $d$ may only transition to either a termination state or a state $s ^ { \\prime }$ of type FC with number of neurons $d ^ { \\prime } \\leq d$ . ",
+        "bbox": [
+            174,
+            465,
+            825,
+            535
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "An agent at a state of type convolution (C) may transition to a state with any other layer type. An agent at a state with layer type pooling (P) may transition to a state with any other layer type other than another $\\mathrm { \\bf P }$ state because consecutive pooling layers are equivalent to a single, larger pooling layer which could lie outside of our chosen state space. Furthermore, only states with representation size in bins (8, 4] and (4, 1] may transition to an FC layer, which ensures that the number of weights does not become unreasonably huge. Note that a majority of these constraints are in place to enable faster convergence on our limited hardware (see Section 5) and not a limitation of the method in itself. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            652
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.3 $Q$ -LEARNING TRAINING PROCEDURE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            671,
+            472,
+            685
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "For the iterative $Q$ -learning updates (Equation 3), we set the $Q$ -learning rate $( \\alpha )$ to 0.01. In addition, we set the discount factor $( \\gamma )$ to 1 to not over-prioritize short-term rewards. We decrease $\\epsilon$ from 1.0 to 0.1 in steps, where the step-size is defined by the number of unique models trained (Table 2). At $\\epsilon = 1 . 0$ , the agent samples CNN architecture with a random walk along a uniformly weighted Markov chain. Every topology sampled by the agent is trained using the procedure described in Section 5, and the prediction performance of this network topology on the validation set is recorded. We train a larger number of models at $\\epsilon = 1 . 0$ as compared to other values of $\\epsilon$ to ensure that the agent has adequate time to explore before it begins to exploit. We stop the agent at $\\epsilon = 0 . 1$ (and not at $\\epsilon = 0$ ) to obtain a stochastic final policy, which generates perturbations of the global minimum.2 Ideally, we want to identify several well-performing model topologies, which can then be ensembled to improve prediction performance. ",
+        "bbox": [
+            173,
+            696,
+            826,
+            851
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "During the entire training process (starting at $\\epsilon = 1 . 0$ ), we maintain a replay dictionary which stores (i) the network topology and (ii) prediction performance on a validation set, for all of the sampled ",
+        "bbox": [
+            174,
+            857,
+            821,
+            886
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/f11bc8b6423eda9378277a460cf23802eea7aa8b7e0c5247c91b8439f4a38f24.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>E</td><td rowspan=1 colspan=1>1.0</td><td rowspan=1 colspan=1>0.9</td><td rowspan=1 colspan=1>0.8</td><td rowspan=1 colspan=1>0.7</td><td rowspan=1 colspan=1>0.6</td><td rowspan=1 colspan=1>0.5</td><td rowspan=1 colspan=1>0.4</td><td rowspan=1 colspan=1>0.3</td><td rowspan=1 colspan=1>0.2</td><td rowspan=1 colspan=1>0.1</td></tr><tr><td rowspan=1 colspan=1>#ModelsTrained</td><td rowspan=1 colspan=1>1500</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>100</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td><td rowspan=1 colspan=1>150</td></tr></table>",
+        "bbox": [
+            199,
+            101,
+            797,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: \u000f Schedule. The learning agent trains the specified number of unique models at each \u000f. ",
+        "bbox": [
+            184,
+            142,
+            807,
+            157
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "models. If a model that has already been trained is re-sampled, it is not re-trained, but instead the previously found validation accuracy is presented to the agent. After each model is sampled and trained, the agent randomly samples 100 models from the replay dictionary and applies the $Q$ -value update defined in Equation 3 for all transitions in each sampled sequence. The $Q$ -value update is applied to the transitions in temporally reversed order, which has been shown to speed up $Q$ -values convergence (Lin, 1993). ",
+        "bbox": [
+            174,
+            172,
+            825,
+            257
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 EXPERIMENT DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            277,
+            395,
+            294
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "During the model exploration phase, we trained each network topology with a quick and aggressive training scheme. For each experiment, we created a validation set by randomly taking 5,000 samples from the training set such that the resulting class distributions were unchanged. For every network, a dropout layer was added after every two layers. The $i ^ { t h }$ dropout layer, out of a total $n$ dropout layers, had a dropout probability of $\\dot { \\frac { \\ i } { 2 n } }$ . Each model was trained for a total of 20 epochs with the Adam optimizer (Kingma & Ba, 2014) with $\\beta _ { 1 } = 0 . 9$ , $\\beta _ { 2 } = 0 . 9 9 9$ , $\\varepsilon = 1 0 ^ { - 8 }$ . The batch size was set to 128, and the initial learning rate was set to 0.001. If the model failed to perform better than a random predictor after the first epoch, we reduced the learning rate by a factor of 0.4 and restarted training, for a maximum of 5 restarts. For models that started learning (i.e., performed better than a random predictor), we reduced the learning rate by a factor of 0.2 every 5 epochs. All weights were initialized with Xavier initialization (Glorot & Bengio, 2010). Our experiments using Caffe (Jia et al., 2014) took 8-10 days to complete for each dataset with a hardware setup consisting of 10 NVIDIA GPUs. ",
+        "bbox": [
+            173,
+            310,
+            825,
+            492
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "After the agent completed the $\\epsilon$ schedule (Table 2), we selected the top ten models that were found over the course of exploration. These models were then finetuned using a much longer training schedule, and only the top five were used for ensembling. We now provide details of the datasets and the finetuning process. ",
+        "bbox": [
+            174,
+            500,
+            825,
+            555
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The Street View House Numbers (SVHN) dataset has 10 classes with a total of 73,257 samples in the original training set, 26,032 samples in the test set, and 531,131 additional samples in the extended training set. During the exploration phase, we only trained with the original training set, using 5,000 random samples as validation. We finetuned the top ten models with the original plus extended training set, by creating preprocessed training and validation sets as described by Lee et al. (2016). Our final learning rate schedule after tuning on validation set was 0.025 for 5 epochs, 0.0125 for 5 epochs, 0.0001 for 20 epochs, and 0.00001 for 10 epochs. ",
+        "bbox": [
+            174,
+            563,
+            825,
+            660
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "CIFAR-10, the 10 class tiny image dataset, has 50,000 training samples and 10,000 testing samples. During the exploration phase, we took 5,000 random samples from the training set for validation. The maximum layer depth was increased to 18. After the experiment completed, we used the same validation set to tune hyperparameters, resulting in a final training scheme which we ran on the entire training set. In the final training scheme, we set a learning rate of 0.025 for 40 epochs, 0.0125 for 40 epochs, 0.0001 for 160 epochs, and 0.00001 for 60 epochs, with all other parameters unchanged. During this phase, we preprocess using global contrast normalization and use moderate data augmentation, which consists of random mirroring and random translation by up to 5 pixels. ",
+        "bbox": [
+            173,
+            667,
+            825,
+            779
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "MNIST, the 10 class handwritten digits dataset, has 60,000 training samples and 10,000 testing samples. We preprocessed each image with global mean subtraction. In the final training scheme, we trained each model for 40 epochs and decreased learning rate every 5 epochs by a factor of 0.2. For further tuning details please see Appendix C. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            842
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "6 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            863,
+            281,
+            878
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Model Selection Analysis: From $Q$ -learning principles, we expect the learning agent to improve in its ability to pick network topologies as $\\epsilon$ reduces and the agent enters the exploitation phase. In ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/32552c045952a2108296dbbf36564ad8f0b5f3075473a34e23667ff0fce72559.jpg",
+        "image_caption": [],
+        "image_footnote": [],
+        "bbox": [
+            506,
+            104,
+            795,
+            267
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/818d2c4b19fb2d138b036e932e80d2c5a38257b0bfc2910a1ad197b14962fe53.jpg",
+        "image_caption": [
+            "Figure 3: $Q$ -Learning Performance. In the plots, the blue line shows a rolling mean of model accuracy versus iteration, where in each iteration of the algorithm the agent is sampling a model. Each bar (in light blue) marks the average accuracy over all models that were sampled during the exploration phase with the labeled $\\epsilon$ . As $\\epsilon$ decreases, the average accuracy goes up, demonstrating that the agent learns to select better-performing CNN architectures. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            104,
+            468,
+            267
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/e6756f5171e6e93e0d5a10685b9b77948b6c19b9f05100ec2251976e9292687b.jpg",
+        "table_caption": [
+            "Table 3: Error Rate Comparison with CNNs that only use convolution, pooling, and fully connected layers. We report results for CIFAR-10 and CIFAR-100 with moderate data augmentation and results for MNIST and SVHN without any data augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CIFAR-10</td><td>SVHN</td><td>MNIST</td><td>CIFAR-100</td></tr><tr><td>Maxout (Goodfellow et al., 2013)</td><td>9.38</td><td>2.47</td><td>0.45</td><td>38.57</td></tr><tr><td>NIN (Lin et al., 2013)</td><td>8.81</td><td>2.35</td><td>0.47</td><td>35.68</td></tr><tr><td>FitNet (Romero et al., 2014)</td><td>8.39</td><td>2.42</td><td>0.51</td><td>35.04</td></tr><tr><td>HighWay (Srivastava et al.,2015)</td><td>7.72</td><td>-</td><td></td><td></td></tr><tr><td>VGGnet (Simonyan &amp; Zisserman,2014)</td><td>7.25</td><td>=</td><td>=</td><td>=</td></tr><tr><td>All-CNN (Springenberg et al., 2014)</td><td>7.25</td><td>=</td><td>=</td><td>33.71</td></tr><tr><td>MetaQNN (ensemble)</td><td>7.32</td><td>2.06</td><td>0.32</td><td>-</td></tr><tr><td>MetaQNN (top model)</td><td>6.92</td><td>2.28</td><td>0.44</td><td>27.14*</td></tr></table>",
+        "bbox": [
+            223,
+            368,
+            772,
+            484
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Figure 3, we plot the rolling mean of prediction accuracy over 100 models and the mean accuracy of models sampled at different $\\epsilon$ values, for the CIFAR-10 and SVHN experiments. The plots show that, while the prediction accuracy remains flat during the exploration phase $\\epsilon = 1$ ) as expected, the agent consistently improves in its ability to pick better-performing models as $\\epsilon$ reduces from 1 to 0.1. For example, the mean accuracy of models in the SVHN experiment increases from $5 2 . 2 5 \\%$ at $\\epsilon = 1$ to $8 8 . 0 2 \\%$ at $\\epsilon = 0 . 1$ . Furthermore, we demonstrate the stability of the $Q$ -learning procedure with 10 independent runs on a subset of the SVHN dataset in Section D.1 of the Appendix. Additional analysis of $Q$ -learning results can be found in Section D.2. ",
+        "bbox": [
+            173,
+            561,
+            825,
+            674
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The top models selected by the $Q$ -learning agent vary in the number of parameters but all demonstrate high performance (see Appendix Tables 1-3). For example, the number of parameters for the top five CIFAR-10 models range from 11.26 million to 1.10 million, with only a $2 . 3 2 \\%$ decrease in test error. We find design motifs common to the top hand-crafted network architectures as well. For example, the agent often chooses a layer of type $C ( N , 1 , 1 )$ as the first layer in the network. These layers generate $N$ learnable linear transformations of the input data, which is similar in spirit to preprocessing of input data from RGB to a different color spaces such as YUV, as found in prior work (Sermanet et al., 2012; 2013). ",
+        "bbox": [
+            173,
+            680,
+            825,
+            791
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Prediction Performance: We compare the prediction performance of the MetaQNN networks discovered by the $Q$ -learning agent with state-of-the-art methods on three datasets. We report the accuracy of our best model, along with an ensemble of top five models. First, we compare MetaQNN with six existing architectures that are designed with standard convolution, pooling, and fully-connected layers alone, similar to our designs. As seen in Table 3, our top model alone, as well as the committee ensemble of five models, outperforms all similar models. Next, we compare our results with six top networks overall, which contain complex layer types and design ideas, including generalized pooling functions, residual connections, and recurrent modules. Our results are competitive with these methods as well (Table 4). Finally, our method outperforms existing automated network design methods. MetaQNN obtains an error of $6 . 9 2 \\%$ as compared to $2 1 . 2 \\%$ reported by Bergstra et al. (2011) on CIFAR-10; and it obtains an error of $0 . 3 2 \\%$ as compared to $7 . 9 \\%$ reported by Verbancsics & Harguess (2013) on MNIST. ",
+        "bbox": [
+            173,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/04dac518be9d1dbeb26306298594acaa705c872c5f3c9d6f7e2cab33fe2aad4e.jpg",
+        "table_caption": [
+            "Table 4: Error Rate Comparison with state-of-the-art methods with complex layer types. We report results for CIFAR-10 and CIFAR-100 with moderate data augmentation and results for MNIST and SVHN without any data augmentation. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>CIFAR-10</td><td>SVHN</td><td>MNIST</td><td>CIFAR-100</td></tr><tr><td>DropConnect (Wan et al., 2013)</td><td>9.32</td><td>1.94</td><td>0.57</td><td></td></tr><tr><td>DSN (Lee et al., 2015)</td><td>8.22</td><td>1.92</td><td>0.39</td><td>34.57</td></tr><tr><td>R-CNN (Liang&amp; Hu,2015)</td><td>7.72</td><td>1.77</td><td>0.31</td><td>31.75</td></tr><tr><td>MetaQNN (ensemble)</td><td>7.32</td><td>2.06</td><td>0.32</td><td>-</td></tr><tr><td>MetaQNN (top model)</td><td>6.92</td><td>2.28</td><td>0.44</td><td>27.14*</td></tr><tr><td>Resnet(110) (He et al.,2015)</td><td>6.61</td><td>1</td><td></td><td></td></tr><tr><td>Resnet(1001) (He et al.,2016)</td><td>4.62</td><td>=</td><td>=</td><td>22.71</td></tr><tr><td>ELU (Clevert et al., 2015)</td><td>6.55</td><td>=</td><td>=</td><td>24.28</td></tr><tr><td>Tree+Max-Avg (Lee et al.,2016)</td><td>6.05</td><td>1.69</td><td>0.31</td><td>32.37</td></tr></table>",
+        "bbox": [
+            246,
+            101,
+            751,
+            229
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/5bca5f49fd7e7bdf163b04f713552739e09b18b7c8a5590e1d004c1fc457ca0c.jpg",
+        "table_caption": [
+            "Table 5: Prediction Error for the top MetaQNN (CIFAR-10) model trained for other tasks. Finetuning refers to initializing training with the weights found for the optimal CIFAR-10 model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td>CIFAR-100</td><td>SVHN</td><td>MNIST</td></tr><tr><td>Training from scratch</td><td>27.14</td><td>2.48</td><td>0.80</td></tr><tr><td>Finetuning</td><td>34.93</td><td>4.00</td><td>0.81</td></tr><tr><td>State-of-the-art</td><td>24.28 (Clevert et al.,2015)</td><td>1.69 (Lee et al., 2016)</td><td>0.31 (Lee et al.,2016)</td></tr></table>",
+        "bbox": [
+            184,
+            297,
+            812,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            421,
+            825,
+            463
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The difference in validation error between the top 10 models for MNIST was very small, so we also created an ensemble with all 10 models. This ensemble achieved a test error of ${ \\bf0 . 2 8 \\% }$ —which beats the current state-of-the-art on MNIST without data augmentation. ",
+        "bbox": [
+            174,
+            469,
+            825,
+            512
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The best CIFAR-10 model performs $1 \\%$ better than the four next best models, which is why the ensemble accuracy is lower than the best model’s accuracy. We posit that the CIFAR-10 MetaQNN did not have adequate exploration time given the larger state space compared to that of the SVHN experiment, causing it to not find more models with performance similar to the best model. Furthermore, the coarse training scheme could have been not as well suited for CIFAR-10 as it was for SVHN, causing some models to under perform. ",
+        "bbox": [
+            174,
+            520,
+            825,
+            603
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Transfer Learning Ability: Network designs such as VGGnet (Simonyan & Zisserman, 2014) can be adopted to solve a variety of computer vision problems. To check if the MetaQNN networks provide similar transfer learning ability, we use the best MetaQNN model on the CIFAR-10 dataset for training other computer vision tasks. The model performs well (Table 5) both when training from random initializations, and finetuning from existing weights. ",
+        "bbox": [
+            174,
+            609,
+            825,
+            680
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7 CONCLUDING REMARKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            703,
+            411,
+            719
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neural networks are being used in an increasingly wide variety of domains, which calls for scalable solutions to produce problem-specific model architectures. We take a step towards this goal and show that a meta-modeling approach using reinforcement learning is able to generate tailored CNN designs for different image classification tasks. Our MetaQNN networks outperform previous metamodeling methods as well as hand-crafted networks which use the same types of layers. ",
+        "bbox": [
+            174,
+            737,
+            823,
+            806
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "While we report results for image classification problems, our method could be applied to different problem settings, including supervised (e.g., classification, regression) and unsupervised (e.g., autoencoders). The MetaQNN method could also aid constraint-based network design, by optimizing parameters such as size, speed, and accuracy. For instance, one could add a threshold in the state-action space barring the agent from creating models larger than the desired limit. In addition, one could modify the reward function to penalize large models for constraining memory or penalize slow forward passes to incentivize quick inference. ",
+        "bbox": [
+            174,
+            813,
+            823,
+            883
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "There are several future avenues for research in reinforcement learning-driven network design as well. In our current implementation, we use the same set of hyperparameters to train all network topologies during the $Q$ -learning phase and further finetune the hyperparameters for top models selected by the MetaQNN agent. However, our approach could be combined with hyperparameter optimization methods to further automate the network design process. Moreover, we constrict the state-action space using coarse, discrete bins to accelerate convergence. It would be possible to move to larger state-action spaces using methods for $Q$ -function approximation (Bertsekas, 2015; Mnih et al., 2015). ",
+        "bbox": [
+            174,
+            138,
+            825,
+            251
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            266,
+            326,
+            280
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We thank Peter Downs for creating the project website and contributing to illustrations. We acknowledge Center for Bits and Atoms at MIT for their help with computing resources. Finally, we thank members of Camera Culture group at MIT Media Lab for their help and support. ",
+        "bbox": [
+            176,
+            290,
+            821,
+            332
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            353,
+            285,
+            368
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sander Adam, Lucian Busoniu, and Robert Babuska. Experience replay for real-time reinforcement learning control. IEEE Transactions on Systems, Man, and Cybernetics, Part C (Applications and Reviews), 42(2):201–212, 2012. ",
+        "bbox": [
+            176,
+            376,
+            823,
+            419
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James Bergstra, Daniel Yamins, and David D Cox. Making a science of model search: Hyperparameter optimization in hundreds of dimensions for vision architectures. ICML (1), 28:115–123, 2013. ",
+        "bbox": [
+            174,
+            428,
+            821,
+            469
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "James S Bergstra, Remi Bardenet, Yoshua Bengio, and Bal ´ azs K ´ egl. Algorithms for hyper-parameter ´ optimization. NIPS, pp. 2546–2554, 2011. ",
+        "bbox": [
+            171,
+            479,
+            825,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Dimitri P Bertsekas. Convex optimization algorithms. Athena Scientific Belmont, 2015. ",
+        "bbox": [
+            171,
+            516,
+            751,
+            532
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and accurate deep network ´ learning by exponential linear units (ELUs). arXiv preprint arXiv:1511.07289, 2015. ",
+        "bbox": [
+            173,
+            541,
+            821,
+            570
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Tobias Domhan, Jost Tobias Springenberg, and Frank Hutter. Speeding up automatic hyperparameter optimization of deep neural networks by extrapolation of learning curves. IJCAI, 2015. ",
+        "bbox": [
+            171,
+            579,
+            821,
+            608
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Xavier Glorot and Yoshua Bengio. Understanding the difficulty of training deep feedforward neural networks. AISTATS, 9:249–256, 2010. ",
+        "bbox": [
+            171,
+            616,
+            823,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ian J Goodfellow, David Warde-Farley, Mehdi Mirza, Aaron C Courville, and Yoshua Bengio. Maxout networks. ICML (3), 28:1319–1327, 2013. ",
+        "bbox": [
+            169,
+            654,
+            823,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. arXiv preprint arXiv:1512.03385, 2015. ",
+        "bbox": [
+            169,
+            691,
+            823,
+            722
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Identity mappings in deep residual networks. In European Conference on Computer Vision, pp. 630–645. Springer, 2016. ",
+        "bbox": [
+            171,
+            729,
+            823,
+            758
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yangqing Jia, Evan Shelhamer, Jeff Donahue, Sergey Karayev, Jonathan Long, Ross Girshick, Sergio Guadarrama, and Trevor Darrell. Caffe: Convolutional architecture for fast feature embedding. arXiv preprint arXiv:1408.5093, 2014. ",
+        "bbox": [
+            174,
+            767,
+            823,
+            810
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Leslie Pack Kaelbling, Michael L Littman, and Andrew W Moore. Reinforcement learning: A survey. Journal of Artificial Intelligence Research, 4:237–285, 1996. ",
+        "bbox": [
+            173,
+            819,
+            823,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980, 2014. ",
+        "bbox": [
+            174,
+            857,
+            823,
+            886
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, Yoshua Bengio, and Geoffrey Hinton. Deep learning. Nature, 521(7553):436–444, 2015. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Chen-Yu Lee, Saining Xie, Patrick Gallagher, Zhengyou Zhang, and Zhuowen Tu. Deeplysupervised nets. AISTATS, 2(3):6, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Chen-Yu Lee, Patrick W Gallagher, and Zhuowen Tu. Generalizing pooling functions in convolutional neural networks: Mixed, gated, and tree. International Conference on Artificial Intelligence and Statistics, 2016. ",
+        "bbox": [
+            173,
+            141,
+            821,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Levine, Chelsea Finn, Trevor Darrell, and Pieter Abbeel. End-to-end training of deep visuomotor policies. JMLR, 17(39):1–40, 2016. ",
+        "bbox": [
+            173,
+            194,
+            820,
+            223
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ming Liang and Xiaolin Hu. Recurrent convolutional neural network for object recognition. CVPR, pp. 3367–3375, 2015. ",
+        "bbox": [
+            173,
+            232,
+            821,
+            262
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Timothy P Lillicrap, Jonathan J Hunt, Alexander Pritzel, Nicolas Heess, Tom Erez, Yuval Tassa, David Silver, and Daan Wierstra. Continuous control with deep reinforcement learning. arXiv preprint arXiv:1509.02971, 2015. ",
+        "bbox": [
+            171,
+            271,
+            823,
+            314
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Long-Ji Lin. Self-improving reactive agents based on reinforcement learning, planning and teaching. Machine Learning, 8(3-4):293–321, 1992. ",
+        "bbox": [
+            173,
+            324,
+            821,
+            353
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Long-Ji Lin. Reinforcement learning for robots using neural networks. Technical report, DTIC Document, 1993. ",
+        "bbox": [
+            173,
+            362,
+            821,
+            392
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Min Lin, Qiang Chen, and Shuicheng Yan. Network in network. arXiv preprint arXiv:1312.4400, 2013. ",
+        "bbox": [
+            171,
+            400,
+            823,
+            430
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "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. ",
+        "bbox": [
+            174,
+            439,
+            823,
+            483
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Nicolas Pinto, David Doukhan, James J DiCarlo, and David D Cox. A high-throughput screening approach to discovering good forms of biologically inspired visual representation. PLoS Computational Biology, 5(11):e1000579, 2009. ",
+        "bbox": [
+            174,
+            492,
+            825,
+            535
+        ],
+        "page_idx": 9
+    },
+    {
+        "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": [
+            173,
+            544,
+            823,
+            574
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Shreyas Saxena and Jakob Verbeek. Convolutional neural fabrics. In Advances in Neural Information Processing Systems 29, pp. 4053–4061. 2016. ",
+        "bbox": [
+            173,
+            583,
+            821,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "J David Schaffer, Darrell Whitley, and Larry J Eshelman. Combinations of genetic algorithms and neural networks: A survey of the state of the art. International Workshop on Combinations of Genetic Algorithms and Neural Networks, pp. 1–37, 1992. ",
+        "bbox": [
+            173,
+            621,
+            825,
+            665
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet, Soumith Chintala, and Yann LeCun. Convolutional neural networks applied to house numbers digit classification. ICPR, pp. 3288–3291, 2012. ",
+        "bbox": [
+            173,
+            674,
+            823,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pierre Sermanet, Koray Kavukcuoglu, Soumith Chintala, and Yann LeCun. Pedestrian detection with unsupervised multi-stage feature learning. CVPR, pp. 3626–3633, 2013. ",
+        "bbox": [
+            171,
+            712,
+            823,
+            742
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Bobak Shahriari, Kevin Swersky, Ziyu Wang, Ryan P Adams, and Nando de Freitas. Taking the human out of the loop: A review of bayesian optimization. Proceedings of the IEEE, 104(1): 148–175, 2016. ",
+        "bbox": [
+            173,
+            751,
+            823,
+            795
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David Silver, Aja Huang, Chris J Maddison, Arthur Guez, Laurent Sifre, George Van Den Driessche, Julian Schrittwieser, Ioannis Antonoglou, Veda Panneershelvam, Marc Lanctot, et al. Mastering the game of go with deep neural networks and tree search. Nature, 529(7587):484–489, 2016. ",
+        "bbox": [
+            176,
+            804,
+            823,
+            847
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karen Simonyan and Andrew Zisserman. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014. ",
+        "bbox": [
+            173,
+            856,
+            821,
+            886
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jasper Snoek, Hugo Larochelle, and Ryan P Adams. Practical bayesian optimization of machine learning algorithms. NIPS, pp. 2951–2959, 2012. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jost Tobias Springenberg, Alexey Dosovitskiy, Thomas Brox, and Martin Riedmiller. Striving for simplicity: The all convolutional net. arXiv preprint arXiv:1412.6806, 2014.   \nRupesh Kumar Srivastava, Klaus Greff, and Jurgen Schmidhuber. Highway networks. ¨ arXiv preprint arXiv:1505.00387, 2015.   \nKenneth O Stanley and Risto Miikkulainen. Evolving neural networks through augmenting topologies. Evolutionary Computation, 10(2):99–127, 2002.   \nKevin Swersky, Jasper Snoek, and Ryan P Adams. Multi-task bayesian optimization. NIPS, pp. 2004–2012, 2013.   \nPhillip Verbancsics and Josh Harguess. Generative neuroevolution for deep learning. arXiv preprint arXiv:1312.5355, 2013.   \nJoannes Vermorel and Mehryar Mohri. Multi-armed bandit algorithms and empirical evaluation. European Conference on Machine Learning, pp. 437–448, 2005.   \nLi Wan, Matthew Zeiler, Sixin Zhang, Yann L Cun, and Rob Fergus. Regularization of neural networks using dropconnect. ICML, pp. 1058–1066, 2013.   \nChristopher John Cornish Hellaby Watkins. Learning from delayed rewards. PhD thesis, University of Cambridge, England, 1989. ",
+        "bbox": [
+            171,
+            102,
+            826,
+            401
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            263,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            136,
+            315,
+            151
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "We first describe the main components of the MetaQNN algorithm. Algorithm 1 shows the main loop, where the parameter $M$ would determine how many models to run for a given $\\epsilon$ and the parameter $K$ would determine how many times to sample the replay database to update $Q$ -values on each iteration. The function TRAIN refers to training the specified network and returns a validation accuracy. Algorithm 2 details the method for sampling a new network using the $\\epsilon$ -greedy strategy, where we assume we have a function TRANSITION that returns the next state given a state and action. Finally, Algorithm 3 implements the $Q$ -value update detailed in Equation 3, with discounting factor set to 1, for an entire state sequence in temporally reversed order. ",
+        "bbox": [
+            173,
+            167,
+            825,
+            280
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 $Q$ -learning For CNN Topologies ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            296,
+            475,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Initialize: replay memory $ [ ]$ $Q  \\{ ( s , u ) \\forall s \\in S , u \\in \\mathcal { U } ( s ) \\ : \\ 0 . 5 \\}$   \nfor episode $= 1$ to $M$ do $S$ , U ← SAMPLE NEW NETWORK(\u000f, Q) accuracy $ \\mathrm { T R A I N } ( S )$ replay memory.append((S, U, accuracy)) for memory $= 1$ to $K$ do $S _ { S A M P L E }$ , $U _ { S A M P L E }$ , accuracySAMP LE Uniform{replay memory} $Q $ UPDATE Q VALUES( $Q$ , $S _ { S A M P L E }$ , $U _ { S A M P L E }$ , accuracySAMP LE) end for   \nend for ",
+        "bbox": [
+            183,
+            316,
+            745,
+            483
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 2 SAMPLE NEW NETWORK(\u000f, Q) ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            496,
+            531
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Initialize: state sequence $S = [ s _ { \\mathrm { S T A R T } } ]$ action sequence $U = [ ]$   \nwhile $U [ - 1 ] \\neq$ terminate do $\\alpha \\sim \\mathrm { U n i f o r m } [ 0 , 1 )$ if $\\alpha > \\epsilon$ then u = argmaxu∈U(S[−1]) Q[(S[−1], u)] s0 = TRANSITION(S[−1], u) else u ∼ Uniform{U(S[−1])} s0 = TRANSITION(S[−1], u) end if U.append $( u )$ if $u : =$ terminate then S.append $\\left( s ^ { \\prime } \\right)$ end if   \nend while   \nreturn S, U ",
+        "bbox": [
+            176,
+            536,
+            490,
+            791
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "table",
+        "img_path": "images/b3a435ef78ca135bca68ea5ed29a97571710a4215efe3d1348bc95ab6c7ef522.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Algorithm3UPDATE_Q_VALUES(Q,S,U,accuracy)</td></tr><tr><td>Q[S[-1],U[-1]] = (1- α)Q[S[-1],U[-1] + α·accuracy</td></tr><tr><td>fori= length(S) - 2 to 0 do</td></tr><tr><td>Q[S[i],U[i]] = (1 -α)Q[S[i], U[i]] + α maxu∈u(S[i+1]) Q[S[i +1],u]</td></tr><tr><td>end for return Q</td></tr></table>",
+        "bbox": [
+            174,
+            815,
+            823,
+            912
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "B REPRESENTATION SIZE BINNING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            482,
+            118
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "As mentioned in Section 4.1 of the main text, we introduce a parameter called representation size to prohibit the agent from taking actions that can reduce the intermediate signal representation to a size that is too small for further processing. However, this process leads to uncertainties in state transitions, as illustrated in Figure A1, which is handled by the standard $Q$ -learning formulation. ",
+        "bbox": [
+            174,
+            133,
+            825,
+            190
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/bbf152a1215e64fdb34aeb4684b1733d98942af3e1032056d78615c9c7da28af.jpg",
+        "image_caption": [
+            "Figure A1: Representation size binning: In this figure, we show three example state transitions. The true representation size ( $R$ -size) parameter is included in the figure to show the true underlying state. Assuming there are two $R$ -size bins, $R$ -size $\\mathrm { B i n _ { 1 } }$ : $[ 8 , \\infty )$ and $R$ -size $\\mathrm { B i n _ { 2 } }$ : (0, 7], Figure A1a shows the case where the initial state is in $R$ -size $\\mathrm { B i n _ { 1 } }$ and true representation size is 18. After the agent chooses to pool with a $2 \\times 2$ filter with stride 2, the true representation size reduces to 9 but the $R$ -size bin does not change. In Figure A1b, the same $2 \\times 2$ pooling layer with stride 2 reduces the actual representation size of 14 to 7, but the bin changes to $R$ -size $\\mathrm { B i n _ { 2 } }$ . Therefore, in figures A1a and A1b, the agent ends up in different final states, despite originating in the same initial state and choosing the same action. Figure A1c shows that in our state-action space, when the agent takes an action that reduces the representation size, it will have uncertainty in which state it will transition to. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            225,
+            205,
+            767,
+            377
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "C MNIST EXPERIMENT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            558,
+            390,
+            574
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We noticed that the final MNIST models were prone to overfitting, so we increased dropout and did a small grid search for the weight regularization parameter. For both tuning and final training, we warmed the model with the learned weights from after the first epoch of initial training. The final models and solvers can be found on our project website https://bowenbaker.github.io/metaqnn/. Figure A2 shows the $Q$ -Learning performance for the MNIST experiment. ",
+        "bbox": [
+            174,
+            589,
+            825,
+            660
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D FURTHER ANALYSIS OF $Q$ -LEARNING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            680,
+            524,
+            696
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 of the main text and Figure A2 show that as the agent begins to exploit, it improves in architecture selection. It is also informative to look at the distribution of models chosen at each $\\epsilon$ . Figure A4 gives further insight into the performance achieved at each $\\epsilon$ for both experiments. ",
+        "bbox": [
+            174,
+            713,
+            825,
+            755
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "D.1 $Q$ -LEARNING STABILITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            772,
+            392,
+            786
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Because the $Q$ -learning agent explores via a random or semi-random distribution, it is natural to ask whether the agent can consistently improve architecture performance. While the success of the three independent experiments described in the main text allude to stability, here we present further evidence. We conduct 10 independent runs of the $Q$ -learning procedure on $10 \\%$ of the SVHN dataset (which corresponds to $\\sim 7 { , } 0 0 0$ training examples). We use a smaller dataset to reduce the computation time of each independent run to 10GPU-days, as opposed to the 100GPU-days it would take on the full dataset. As can be seen in Figure A3, the $Q$ -learning procedure with the exploration schedule detailed in Table 2 is fairly stable. The standard deviation at $\\epsilon = 1$ is notably smaller than at other stages, which we attribute to the large difference in number of samples at each stage. ",
+        "bbox": [
+            174,
+            797,
+            825,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "image",
+        "img_path": "images/1040a48db3c9107445d63faf705edb1033b4dc791f36b6e6a2203c2e49609895.jpg",
+        "image_caption": [
+            "Figure A2: MNIST $Q$ -Learning Performance. The blue line shows a rolling mean of model accuracy versus iteration, where in each iteration of the algorithm the agent is sampling a model. Each bar (in light blue) marks the average accuracy over all models that were sampled during the exploration phase with the labeled $\\epsilon$ . As $\\epsilon$ decreases, the average accuracy goes up, demonstrating that the agent learns to select better-performing CNN architectures. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            341,
+            103,
+            630,
+            267
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "image",
+        "img_path": "images/a64860a6aa693382887f15593297e5ca583d08775c931f3f68c8338f77f67885.jpg",
+        "image_caption": [
+            "Figure A3: Figure A3a shows the mean model accuracy and standard deviation at each $\\epsilon$ over 10 independent runs of the $Q$ -learning procedure on $10 \\%$ of the SVHN dataset. Figure A3b shows the mean model accuracy at each $\\epsilon$ for each independent experiment. Despite some variance due to a randomized exploration strategy, each independent run successfully improves architecture performance. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            378,
+            797,
+            540
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Furthermore, the best model found during each run had remarkably similar performance with a mean accuracy of $8 8 . 2 5 \\%$ and standard deviation of $0 . 5 8 \\%$ , which shows that each run successfully found at least one very high performing model. Note that we did not use an extended training schedule to improve performance in this experiment. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            705
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "D.2 $Q$ -VALUE ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            723,
+            361,
+            738
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We now analyze the actual $Q$ -values generated by the agent during the training process. The learning agent iteratively updates the $Q$ -values of each path during the $\\epsilon$ -greedy exploration. Each $Q$ -value is initialized at 0.5. After the $\\epsilon$ -schedule is complete, we can analyze the final $Q$ -value associated with each path to gain insights into the layer selection process. In the left column of Figure A5, we plot the average $Q$ -value for each layer type at different layer depths (for both SVHN and CIFAR10) datasets. Roughly speaking, a higher $Q$ -value associated with a layer type indicates a higher probability that the agent will pick that layer type. In Figure A5, we observe that, while the average $Q$ -value is higher for convolution and pooling layers at lower layer depths, the $Q$ -values for fullyconnected and termination layers (softmax and global average pooling) increase as we go deeper into the network. This observation matches with traditional network designs. ",
+        "bbox": [
+            174,
+            750,
+            825,
+            888
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We can also plot the average $Q$ -values associated with different layer parameters for further analysis. In the right column of Figure A5, we plot the average $Q$ -values for convolution layers with receptive field sizes 1, 3, and 5 at different layer depths. The plots show that layers with receptive field size of 5 have a higher $Q$ -value as compared to sizes 1 and 3 as we go deeper into the networks. This indicates that it might be beneficial to use larger receptive field sizes in deeper networks. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In summary, the $Q$ -learning method enables us to perform analysis on the relative benefits of different design parameters of our state space, and possibly gain insights for new CNN designs. ",
+        "bbox": [
+            171,
+            152,
+            821,
+            181
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "E TOP TOPOLOGIES SELECTED BY ALGORITHM ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            202,
+            581,
+            218
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "In Tables A1 through A3, we present the top five model architectures selected with Q-learning for each dataset, along with their prediction error reported on the test set, and their total number of parameters. To download the Caffe solver and prototext files, please visit https://bowenbaker.github.io/metaqnn/. ",
+        "bbox": [
+            173,
+            232,
+            825,
+            289
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/a4b3d984ac022413e835893b43a98af621f1a2a434db861c5c2de49eb522ef56.jpg",
+        "table_caption": [
+            "Table A1: Top 5 model architectures: CIFAR-10. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model Architecture</td><td rowspan=1 colspan=1>Test Error (%)</td><td rowspan=1 colspan=1>#Params (10)</td></tr><tr><td rowspan=1 colspan=1>[C(512,5,1), C(256,3,1), C(256,5,1), C(256,3,1),P(5,3),C(512,3,1),C(512,5,1), P(2,2), SM(10)]</td><td rowspan=1 colspan=1>6.92</td><td rowspan=1 colspan=1>11.18</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1),C(512,3,1),C(64,1,1), C(128,3,1),P(2,2),C(256,3,1),P(2,2), C(512,3,1),P(3,2),,SM(10)]</td><td rowspan=1 colspan=1>8.78</td><td rowspan=1 colspan=1>2.17</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1),C(128,1,1),C(512,5,1),P(2,2),C(128,3,1),P(2,2),C(64,3,1),C(64,5,1), S(10)]</td><td rowspan=1 colspan=1>8.88</td><td rowspan=1 colspan=1>2.42</td></tr><tr><td rowspan=1 colspan=1>[C(256,3,1),C(256,3,1),P(5,3),C(256,1,1),C(128,3,1),P(2,2),C(128,3,1), ,SM(10)]</td><td rowspan=1 colspan=1>9.24</td><td rowspan=1 colspan=1>1.10</td></tr><tr><td rowspan=1 colspan=1>[C(128,5,1),C(512,3,1),P(2,2),C(128,1,1),C(128,5,1),P(3,2),C(512,3,1), SM(10)]</td><td rowspan=1 colspan=1>11.63</td><td rowspan=1 colspan=1>1.66</td></tr></table>",
+        "bbox": [
+            173,
+            301,
+            828,
+            446
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/baa9e0df7c9aaabf85d8dd3e8b0b2449cca8d51e81d0dcea57a86fe0e24cfc81.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model Architecture</td><td rowspan=1 colspan=1>Test Error (%)</td><td rowspan=1 colspan=1>#Params (106)</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1), P(2,2),C(64,5,1),C(512,5,1),C(256,3,1),C(512,3,1),P(2,2), C(512,3,1),C(256,5,1),C(256,3,1),C(128,5,1),C(64,3,1),SM(10)]</td><td rowspan=1 colspan=1>2.24</td><td rowspan=1 colspan=1>9.81</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1), C(256,5,1)，C(128,5,1), P(2,2)，C(256,5,1),C(256,1,1),C(256,3,1), C(256,3,1), C(256,5,1), C(512,5,1), C(256,3,1),C(128,3,1), SM(10)]</td><td rowspan=1 colspan=1>2.28</td><td rowspan=1 colspan=1>10.38</td></tr><tr><td rowspan=1 colspan=1>[C(128,5,1)， C(128,3,1),C(64,5,1),P(5,3),C(128,3,1),C(512,5,1),C(256,5,1), C(128,5,1), C(128,5,1),,C(128,3,1), SM(10)]</td><td rowspan=1 colspan=1>2.32</td><td rowspan=1 colspan=1>6.83</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1),C(256,5,1),C(128,5,1),C(256,3,1),C(256,5,1), P(2,2),C(128,1,1),C(512,3,1),C(256,5,1),P(2,2),C(64,5,1),C(64,1,1),SM(10)]</td><td rowspan=1 colspan=1>2.35</td><td rowspan=1 colspan=1>6.99</td></tr><tr><td rowspan=1 colspan=1>[C(128,1,1), C(256,5,1), C(128,5,1), C(256,5,1), C(256,5,1),C(256,1,1), P(3,2), C(128,1,1),C(256,5,1),C(512,5,1),C(256,3,1),C(128,3,1), SM(10)]</td><td rowspan=1 colspan=1>2.36</td><td rowspan=1 colspan=1>10.05</td></tr></table>",
+        "bbox": [
+            173,
+            493,
+            828,
+            689
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Table A2: Top 5 model architectures: SVHN. Note that we do not report the best accuracy on test set from the above models in Tables 3 and 4 from the main text. This is because the model that achieved $2 . 2 8 \\%$ on the test set performed the best on the validation set. ",
+        "bbox": [
+            173,
+            699,
+            828,
+            742
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "table",
+        "img_path": "images/d00d2f32a054bee202162ba5892e83cf7cdd1c9ff14df4bdef99a7b889e63f27.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model Architecture</td><td rowspan=1 colspan=1>Test Error (%)</td><td rowspan=1 colspan=1>#Params (10)</td></tr><tr><td rowspan=1 colspan=1>[C(64,1,1)，C(256,3,1)，P(2,2)，C(512,3,1), C(256,1,1), P(5,3),C(256,3,1), C(512,3,1),FC(512), SM(10)]</td><td rowspan=1 colspan=1>0.35</td><td rowspan=1 colspan=1>5.59</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1), C(64,1,1),C(64,3,1), C(64,5,1), P(2,2), C(128,3,1), P(3,2),C(512,3,1), FC(512),FC(128), S(10)]</td><td rowspan=1 colspan=1>0.38</td><td rowspan=1 colspan=1>7.43</td></tr><tr><td rowspan=1 colspan=1>[C(512,1,1), C(128,3,1), C(128,5,1), C(64,1,1), C(256,5,1), C(64,1,1),P(5,3), C(512,1,1), C(512,3,1), C(256,3,1), C(256,5,1), C(256,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.40</td><td rowspan=1 colspan=1>8.28</td></tr><tr><td rowspan=1 colspan=1>[C(64,3,1), C(128,3,1), C(512,1,1), C(256,1,1), C(256,5,1), C(128,3,1),P(5,3), C(512,1,1), C(512,3,1), C(128,5,1), SM(10)]</td><td rowspan=1 colspan=1>0.41</td><td rowspan=1 colspan=1>6.27</td></tr><tr><td rowspan=1 colspan=1>[C(64,3,1),C(128,1,1),P(2,2)， C(256,3,1),C(128,5,1),C(64,1,1),C(512,5,1), C(128,5,1), C(64,1,1), C(512,5,1), C(256,5,1), C(64,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.43</td><td rowspan=1 colspan=1>8.10</td></tr><tr><td rowspan=1 colspan=1>[C(64,1,1),C(256,5,1),,C(256,5,1),C(512,1,1)，C(64,3,1),P(5,3),C(256,5,1), C(256,5,1), C(512,5,1), C(64,1,1), C(128,5,1), C(512,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.44</td><td rowspan=1 colspan=1>9.67</td></tr><tr><td rowspan=1 colspan=1>[C(128,3,1)， C(512,3,1)，P(2,2)， C(256,3,1),，C(128,5,1),C(64,1,1),C(64,5,1), C(512,5,1), GAP(10), SM(10)]</td><td rowspan=1 colspan=1>0.44</td><td rowspan=1 colspan=1>3.52</td></tr><tr><td rowspan=1 colspan=1>[C(256,3,1), C(256,5,1), C(512,3,1), C(256,5,1)，C(512,1,1),P(5,3),C(256,3,1), C(64,3,1), C(256,5,1), C(512,3,1), C(128,5,1), C(512,5,1),SM(10)]</td><td rowspan=1 colspan=1>0.46</td><td rowspan=1 colspan=1>12.42</td></tr><tr><td rowspan=1 colspan=1>[C(512,5,1), C(128,5,1), C(128,5,1), C(128,3,1), C(256,3,1),C(512,5,1), C(256,3,1), C(128,3,1), S(10)]</td><td rowspan=1 colspan=1>0.55</td><td rowspan=1 colspan=1>7.25</td></tr><tr><td rowspan=1 colspan=1>[C(64,5,1),C(512,5,1),P(3,2)，C(256,5,1),C(256,3,1),C(256,3,1),C(128,1,1),C(256,3,1), C(256,5,1), C(64,1,1), C(256,3,1),C(64,3,1),SM(10)]</td><td rowspan=1 colspan=1>0.56</td><td rowspan=1 colspan=1>7.55</td></tr></table>",
+        "bbox": [
+            171,
+            309,
+            828,
+            645
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "text",
+        "text": "Table A3: Top 10 model architectures: MNIST. We report the top 10 models for MNIST because we included all 10 in our final ensemble. Note that we do not report the best accuracy on test set from the above models in Tables 3 and 4 from the main text. This is because the model that achieved $0 . 4 4 \\%$ on the test set performed the best on the validation set. ",
+        "bbox": [
+            173,
+            655,
+            826,
+            712
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/fd32a7a7238161bd217f837e7aa678dfc6a19faca503b359140d345a8d6ea0ab.jpg",
+        "image_caption": [
+            "Figure A4: Accuracy Distribution versus $\\epsilon$ : Figures A4a, A4c, and A4e show the accuracy distribution for each $\\epsilon$ for the SVHN, CIFAR-10, and MNIST experiments, respectively. Figures A4b, A4d, and A4f show the accuracy distributions for the initial $\\epsilon = 1$ and the final $\\epsilon = 0 . 1$ . One can see that the accuracy distribution becomes much more peaked in the high accuracy ranges at small $\\epsilon$ for each experiment. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            189,
+            205,
+            800,
+            734
+        ],
+        "page_idx": 16
+    },
+    {
+        "type": "image",
+        "img_path": "images/7533dcaeb55b1d1b05fd06f4deb470699d4d0219efe173f88397cbc8c105105c.jpg",
+        "image_caption": [
+            "Figure A5: Average $Q$ -Value versus Layer Depth for different layer types are shown in the left column. Average $Q$ -Value versus Layer Depth for different receptive field sizes of the convolution layer are shown in the right column. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            187,
+            170,
+            797,
+            803
+        ],
+        "page_idx": 17
+    }
+]

parse/train/Sk-oDY9ge/Sk-oDY9ge.md

@@ -0,0 +1,277 @@
+# DIET NETWORKS: THIN PARAMETERS FOR FAT GENOMICS
+
+Adriana Romero∗, Pierre Luc Carrier∗, Akram Erraqabi, Tristan Sylvain, Alex Auvolat, Etienne Dejoie
+
+Montreal Institute for Learning Algorithms Montreal, Quebec, Canada firstName.lastName@umontreal.ca, except adriana.romero.soriano@umontreal.ca and pierre-luc.carrier@umontreal.ca
+
+# Marc-Andre Legault ´ 1, Marie-Pierre Dube´1,2,3
+
+1University of Montreal, Faculty of Medicine   
+2Montreal Heart Institute,   
+3Beaulieu-Saucier Pharmacogenomics Centre   
+Montreal, Quebec, Canada   
+marc-andre.legault.1@umontreal.ca   
+marie-pierre.dube@umontreal.ca
+
+# Julie G. Hussin
+
+Wellcome Trust Centre for Human Genetics   
+University of Oxford   
+Oxford, UK   
+julieh@well.ox.ac.uk
+
+# Yoshua Bengio
+
+Montreal Institute for Learning Algorithms Montreal, Quebec, Canada yoshua.umontreal@gmail.com
+
+# ABSTRACT
+
+Learning tasks such as those involving genomic data often poses a serious challenge: the number of input features can be orders of magnitude larger than the number of training examples, making it difficult to avoid overfitting, even when using the known regularization techniques. We focus here on tasks in which the input is a description of the genetic variation specific to a patient, the single nucleotide polymorphisms (SNPs), yielding millions of ternary inputs. Improving the ability of deep learning to handle such datasets could have an important impact in medical research, more specifically in precision medicine, where highdimensional data regarding a particular patient is used to make predictions of interest. Even though the amount of data for such tasks is increasing, this mismatch between the number of examples and the number of inputs remains a concern. Naive implementations of classifier neural networks involve a huge number of free parameters in their first layer (number of input features times number of hidden units): each input feature is associated with as many parameters as there are hidden units. We propose a novel neural network parametrization which considerably reduces the number of free parameters. It is based on the idea that we can first learn or provide a distributed representation for each input feature (e.g. for each position in the genome where variations are observed in data), and then learn (with another neural network called the parameter prediction network) how to map a feature’s distributed representation (based on the feature’s identity not its value) to the vector of parameters specific to that feature in the classifier neural network (the weights which link the value of the feature to each of the hidden units). This approach views the problem of producing the parameters associated with each feature as a multi-task learning problem. We show experimentally on a population stratification task of interest to medical studies that the proposed approach can significantly reduce both the number of parameters and the error rate of the classifier.
+
+# 1 INTRODUCTION
+
+Medical datasets often involve a dire imbalance between the number of training examples and the number of input features, especially when genomic information is used as input to the trained predictor. This is problematic in the context where we want to apply deep learning (which typically involves large models) to precision medicine, i.e., making patient-specific predictions using a potentially large set of input features to better characterize the patient. This paper proposes a novel approach, called Diet Networks, to reparametrize neural networks to considerably reduce their number of free parameters when the input is very high-dimensional and orders of magnitude larger than the number of training examples.
+
+Genomics is the study of the genetic code encapsulated as DNA in all living organisms’ cells. Genomes contain the instructions to produce and regulate all the functional components needed to guide the development and adaptation of living organisms. In the last decades, advances in genomic technologies resulted in an explosion of available data, making it more interesting to apply advanced machine learning techniques such as deep learning. Learning tasks involving genomic data and already tackled by deep learning include: using Convolutional Neural Networks (CNNs) to learn the functional activity of DNA sequences (Basset package, Kelley et al. (2016), predicting effects of noncoding DNA (DeepSEA, Zhou & Troyanskaya (2015)), investigating the regulatory role of RNA binding proteins in alternative splicing (Alipanahi et al., 2015), inferring gene expression patterns (Chen et al., 2016; Singh et al., 2016) and population genetic parameters (Sheehan & Song, 2016) among others (see Leung et al. (2016) for a detailed example). Noticeably, most of these techniques are based on sequence data where convolutional or recurrent networks are appropriate. When the full DNA sequence is unavailable, such as when data is acquired through genotyping, other methods need to be used. All this work shows that deep learning can be used to tackle genomic-related tasks, paving the road towards a better understanding of the biological impact of DNA variation.
+
+Applying deep learning to human genetic variation holds the promise of identifying individuals at risk for medical conditions. Modern genotyping technologies usually target millions of simple variants across the genome, called single nucleotide polymorphisms (SNPs). These genetic mutations result from substitutions from one nucleotide to another (eg. A to C), where both versions exist within a population. In modern studies, as many as 5 millions SNPs can be acquired for every participant. These datasets differ from other types of genomic data because they focus on the genetic differences between individuals which represents a space of high dimensionality where sequencecontext information is unavailable. In medical genetics, these variants are tested for their association with a trait of interest, an approach termed genome-wide association study (GWAS). This methodology aims at finding genetic variants implicated in disease susceptibility, etiology and treatment.
+
+An important confounding factor in GWAS is population stratification, which arises because both disease prevalence and genetic profiles vary from one population to the other. Although most GWAS have been restricted to homogeneous populations, dimensionality reduction techniques are generally used to account for population-level genetic differences (Price et al., 2006). Our experiments compare such dimensionality reduction techniques (based on principal components analysis, PCA) to the proposed Diet Network parametrization, as well as with standard deep networks.
+
+Recently, several machine learning methods have been successfully applied to detect population stratification, based on the presence of systematic differences in genetic variation between populations. For instance, Support Vector Machines (SVM) models have been used multiple times to infer recent genetic ancestry of sub-continental populations (Haasl et al. (2013)), and local ancestry in admixed populations (SupportMix, Omberg et al. (2012), 23andMe, Inc.). However SVM methods are very sensitive to the the kernel choice and the parameters. They also tend to overfit the model selection criterion which usually induces a limitation in its predictive power.
+
+In this work, we are interested in predicting the genetic ancestry of an individual from their SNP data using a novel deep learning approach, Diet Networks, which allow us to considerably reduce the number of free parameters. Therefore, we propose to tackle this problem by introducing a multi-task architecture in which the problem of predicting the appropriate parameters for each input feature is considered like a task in itself, and the same parameter prediction network is used for all of the hundreds of thousands of input features. This parameter prediction network learns to predict these feature-specific parameters as a function of a distributed representation of the feature identity, or feature embedding. The feature embedding can be learned as part of end-to-end training or using other datasets or a priori knowledge about the features. What is important is that two features which are similar in some appropriate sense (in terms of their interactions with other features or other variables observed in any dataset) end up having similar embeddings, and thus a similar parameter vector as output of the parameter prediction network. A practical advantage of this approach is that the parameter prediction network can generalize to new features for which there is no labeled training data (without the target to be predicted by the classifier), so long as it is possible to derive an embedding for that feature (for example using just the unlabeled observations of co-occurences of that feature with other features in human genomes).
+
+An interesting consideration is that from the point of the parameter prediction network, each feature is an example: more features now allow to better train the parameter prediction network. It is like if we were considering not the data matrix itself but its transpose. This is actually how the Diet Network implementation processes the data, by using the transpose of the matrix of input values as the input part of the learning task for the parameter prediction network.
+
+The idea of having two networks interacting with each other and with one producing parameters for the other is well rooted in the machine learning literature (Bengio et al., 1991; Schmidhuber, 1992; Gomez & Schmidhuber, 2005; Stanley et al., 2009; Denil et al., 2013; Andrychowicz et al., 2016). Recent efforts in the same direction include works such as (Bertinetto et al., 2016; Brabandere et al., 2016; Ha et al., 2016) that use a network to predict the parameters of a Convolutional Neural Network (CNN). Brabandere et al. (2016) introduce a dynamic filter module that generates network filters conditioned on an input. Bertinetto et al. (2016) propose to learn the parameters of a deep model in one shot, by training a second network to predict the parameters of the first from a single exemplar. Hypernetworks (Ha et al., 2016) explore the idea of using a small network to predict the parameters of another network, training them in an end-to-end fashion. The small network takes as input the feature embedding from the previous layer and learns the parameters of the current layer.
+
+To the best of our knowledge, deep learning has never been used so far to tackle the problem of ancestry prediction based on SNP data. Compared to other approaches that attempt to learn model parameters using a parameter prediction network, our main goal is to reduce the large number of parameters required by the model, by considering the input features themselves as sub-tasks in a multi-task view of the learning problem, as opposed to constructing a model with even higher capacity, as seen, e.g. in (Ha et al., 2016). Our approach is thus based on building an embedding of these tasks (the features) in order to further reduce the number of parameters.
+
+We evaluate our method on a publicly available dataset for ancestry prediction, the 1000 Genomes dataset1, that best represents the human population diversity. Because population-specific differences in disease and drug response are widespread, identifying an individual’s ancestry heritage based on SNP data is a very important task to help detect biological causation and achieve good predictive performance in precision medicine. Most importantly, ancestry-aware approaches in precision genomics will reduce the hidden risks of genetic testing, by preventing spurious diagnosis and ineffective treatment.
+
+# 2 METHOD
+
+In this section, we describe the Diet Networks as well as the feature embeddings used by the model.
+
+# 2.1 MODEL
+
+Our model aims at reducing the number of free parameters that a network trained on fat data would typically have.
+
+Let $\mathbf { X } \in \mathbb { R } ^ { N \times N _ { d } }$ be a matrix of data, with $N$ samples and $N _ { d }$ features, where $N \ll N _ { d }$ (e. g. $N$ being approximately 100 times smaller than $N _ { d . }$ ). We build a multi-layer perceptron (MLP), which takes $\mathbf { X }$ as input, computes a hidden representation and outputs a prediction $\hat { \mathbf Y }$ . Optionally, the MLP may generate a reconstruction $\hat { \mathbf X }$ of the input data from the hidden representation. Figure 1(a) illustrates this basic network architecture. Let $\mathbf { x _ { i } }$ be one data sample, i.e. a row in $\mathbf { X }$ . The standard formulations to compute its hidden representation $\mathbf { h _ { i } }$ , output prediction $\hat { \mathbf { y } } _ { \mathbf { i } }$ and reconstruction $\hat { \bf x } _ { \bf i }$ are given by
+
+$$
+\mathbf { h _ { i } } = f ( \mathbf { x _ { i } } ) , \quad \hat { \mathbf { y _ { i } } } = g ( \mathbf { h _ { i } } ) , \quad \hat { \mathbf { x _ { i } } } = r ( \mathbf { h _ { i } } ) ,
+$$
+
+where $f , g$ and $r$ are non-linear functions.
+
+![](images/5a4c7493d56a4be3b5a2927448f69fa77c0f63af1cd91a8b998d8317bc19d848.jpg)  
+Figure 1: Our model is composed of 3 networks, one basic and two auxiliary networks: (a) a basic discriminative network with optional reconstruction path (dashed arrow), (b) a network that predicts the input fat layer parameters, and (c) a network that predicts the reconstruction fat layer parameters (if any). First layer in the ”prediction networks” (b, c) represents embedding (Emb.). Each MLP block may contain any number of hidden layers. ${ \bf W _ { e } }$ and $\mathbf { \hat { W } _ { d } ^ { T } }$ represent the parameters of the fat hidden layer and the fat reconstruction layer of the basic network (a), respectively. These parameters are predicted by auxiliary networks (b) and (c) – also called parameter prediction networks – to reduce the number of free parameters of (a).
+
+The number of parameters of the first hidden layer of the architecture grows linearly with the dimensionality of the input data:
+
+$$
+\mathbf { h _ { i } ^ { ( 1 ) } } = f _ { 1 } ( \mathbf { x _ { i } } \mathbf { W _ { e } } + \mathbf { b _ { e } } ) ,
+$$
+
+where ${ \bf W _ { e } }$ and $\mathbf { b _ { e } }$ are the layer’s parameters. Using fat data such as the one described in Section 1, leads to a parameter explosion in this layer, hereafter referred to as fat hidden layer. To give the reader an intuition, consider the case of having an input with $N _ { d } = 3 0 0 K$ , and a hidden layer with $N _ { h } ^ { 1 } = 1 0 0$ , the number of parameters of such a layer would be 30M. The same happens to the number of parameters of the optional reconstruction layer, hereafter referred to as fat reconstruction layer.
+
+In order to mitigate this effect, we introduce an auxiliary network to predict the fat layers’ parameters. The auxiliary network takes as input the transposed data matrix $\mathbf { X ^ { \mathrm { T } } }$ , extracts a feature embedding and learns a function of this embedding, to be used as parameters of a fat layer:
+
+$$
+( \mathbf { W _ { e } } ) _ { \mathbf { j } : } = \phi ( \mathbf { e _ { j } } ) ,
+$$
+
+where $\mathbf { e _ { j } }$ represents the embedding of a feature in $\mathbf { X ^ { \mathrm { T } } }$ , $\phi$ is a non-linear function and $( \mathbf { W _ { e } } ) _ { \mathbf { j } : }$ is the $j$ -th row of ${ \bf W _ { e } }$ . This means that each feature is associated with the vector of values it takes in the dataset (e.g. across the patients). Other representations could be used, e.g., derived from other datasets in which those features interact. Figure 1(b) shows a prediction network which is an auxiliary network that predicts the parameters of the fat hidden layer of our basic network. Following the same spirit, Figure 1(c) highlights the interaction between a second prediction network that predicts the fat reconstruction layer parameters and the basic network. The architectures of both auxiliary networks may share the initial feature embedding.
+
+The feature embeddings used in the auxiliary networks allow us to substantially reduce the number of free parameters of the fat layers of the basic architecture. The auxiliary network should predict a matrix of weights of size $N _ { d } \times N _ { h } ^ { 1 }$ from a feature embedding. Consider a feature embedding that would transform each $N$ -dimensional feature into a $N _ { f }$ -dimensional vector, where $N _ { f } < N$ . The auxiliary network would learn a function $\phi : \mathcal { R } ^ { N _ { f } }  \mathbb { R } ^ { N _ { h } ^ { 1 } }$ . Thus, the fat hidden layer of our basic architecture would have $N _ { f } \times N _ { h } ^ { 1 }$ free parameters (assuming a single layer MLP in the auxiliary network), instead of $N _ { d } \times N _ { h } ^ { 1 }$ . Following our previous example, where $N _ { d } = 3 0 0 K$ and $N _ { h } ^ { 1 } = 1 0 0$ , using an auxiliary network with previously-obtained feature embeddings of dimensionality $N _ { f } =$ 500 would reduce the number of free parameters of the basic network by a factor of 600 (from 30M to 50K).
+
+The model is trained end-to-end by minimizing the following objective function
+
+$$
+\mathcal { H } ( \hat { \mathbf { Y } } , \mathbf { Y } ) + \gamma | | \hat { \mathbf { X } } - \mathbf { X } | | _ { 2 } ^ { 2 } ,
+$$
+
+where $\mathcal { H }$ refers to the cross-entropy, $\mathbf { Y }$ to the true classification labels and $\gamma$ is a tunable parameter to balance the supervised and the reconstruction losses.
+
+# 2.2 FEATURE EMBEDDINGS
+
+The feature embeddings used by the auxiliary networks can be either pre-computed or learnt offline, as well as learnt jointly with the rest of the architecture. In theory, any kind of embedding could be used, as long as we keep in mind that the goal is to reduce the number of free parameters of the basic model. In this work, we considered random projections (Bingham & Mannila, 2001), histograms (which are akin to bag-of-words representations), feature embeddings learnt offline (Mikolov et al., 2013) and feature embeddings jointly learnt with the rest of the proposed architecture.
+
+Random projection: Randomly initializing an MLP defines a random projection. By using such a projection to encode the high-dimensional feature space into a more manageable lower-dimensional space, we were able to obtain decent results.
+
+Per class histogram: For a given SNP, we can define a histogram of the values it can take over the whole population. Once normalized, this yields 3 values per SNP, corresponding to the proportion of the population having the values 0, 1 and 2 respectively for that SNP. After initial tests showed this was too coarse a representation for the dataset, we instead chose to consider the per-class proportion of the three values. With 26 classes in the 1000 Genomes dataset, this yields an embedding of size 78 for each feature. By this method, the matrix $\mathbf { X ^ { \mathrm { T } } }$ is summarized as a $N _ { d } \times 7 8$ matrix, where $N _ { d }$ is the number of SNPs in the dataset.
+
+SNPtoVec: In Mikolov et al. (2013), the authors propose a word embedding that allows good reconstruction of the words’ context (surrounding words) by a neural network. SNPs do not have a similarly well-defined positional context (SNPs close together in our ordering might very well be independent) so our embedding is instead built by training a denoising autoencoder (DAE) (Vincent et al., 2008) on the matrix X. Thus, the DAE learns to recover the values of missing SNPs by leveraging their similarities and cooccurences with other SNPs. Once the DAE is trained, we obtain an encoding for each feature by feeding to the DAE an input where only that feature is active (the other features are set to 0s) and computing the hidden representation of the autoencoder for that single-feature input.
+
+Embedding learnt end-to-end from raw data: In this case, we consider the feature embedding to be another MLP, whose input corresponds to the values that a SNP takes for each of the training samples and, whose parameters are learnt jointly with the rest of the network. Note that the layer(s) corresponding to the feature embedding are shared among auxiliary networks. For experiments reported in Section 4, we used a single hidden layer as embedding.
+
+# 3 DATA: THE 1000 GENOMES PROJECT
+
+The 1000 Genomes project is the first project to sequence the genomes of a large number of people in populations worldwide, yielding the largest public catalog of human genetic variants to date Consortium (2015). This allowed large-scale comparison of DNA sequences from populations, thanks to the presence of genetic variation. Individuals of the 1000 Genomes project are samples taken from 26 populations over the world, which are grouped into 5 geographical regions. Figure 2(a) shows a histogram derived from the 1000 Genomes data, depicting the frequency of individuals per population (ethnicity). Analogously, Figure 2(b) depicts the frequency of individuals per geographical region.
+
+In this dataset, we included 315,345 genetic variants with frequencies of at least $5 \%$ in 3,450 individuals sampled worldwide from 26 populations, interrogated using microarray genotyping technology: the Genome-Wide Human SNP Array 6.0 by Affymetrix. The mutated state is established by comparison to the Genome Reference Consortium human genome (build 37). Since individuals have 2 copies of each genomic position, a sampled individual can have 0, 1 or 2 copies of a genetic mutation, hereafter referred to as an individual genotype. We excluded SNPs positioned on the sex chromosomes and only included SNPs in approximate linkage equilibrium with each other, such that genotypes at neighboring positions are only weakly correlated $( r ^ { 2 } < 0 . 5 )$ .
+
+![](images/09ea8294618b9993a70f96d30ca2f1331641175c150a60f545d07b117b6f0da7.jpg)  
+Figure 2: The 1000 Genomes population distribution:(a) Ethnicity; (b) Geographical Region.
+
+# 4 EXPERIMENTS
+
+In this section, we describe the model architectures, and report and discuss the obtained results.
+
+![](images/0ccd4f6db366387a241d01be92e4ff7d2439249520117517a01010e0b34e0731.jpg)  
+Figure 3: Results of our best model: (a) Confusion matrix per ethnicity; (b) Confusion matrix per large geographical region. The 1000 Genomes legend for population abbreviations can be found in the appendix.
+
+# 4.1 MODEL ARCHITECTURE
+
+We experimented with simple models both in the auxiliary networks and the basic architecture, which yielded very promising results. We designed a basic architecture with 2 hidden layers followed by a softmax layer to perform ancestry prediction. We trained this architecture with and without the assistance of the auxiliary network. Similarly, the auxiliary networks were build by stacking a hidden layer on top of one of the feature embeddings described in Section 2.2. In the reported experiments, all hidden layers have 100 units. All models were trained by means of stochastic gradient descent with adaptive learning rate (Tieleman & Hinton, 2012), both for $\gamma = 0$ and $\gamma = 1 0$ , using dropout, limiting the norm of the weights to 1 and/or applying weight decay to reduce overfitting.2.
+
+# 4.2 RESULTS
+
+Given the relatively small amount of samples in the 1000 Genomes data, we report results obtained by 5-fold cross validation of the model. We split the data into 5 folds of equal size. A single fold is retained for test, whereas three of the remaining folds are used as training data and the final fold is used as validation data. We repeated the process 5 times (one per fold) and report the means and standard deviations of results on the different test sets.
+
+Table 1 summarizes the results obtained for each model. First, we observe that, for most of Diet Network architectures, training with an reconstruction term in the loss $( \gamma > 0 )$ ) reduces the misclassification error and provides a lower standard deviation over the folds, suggesting more robustness to variations in the learnt feature embedding.
+
+Training the models end-to-end, with no pre-computed feature embedding, yielded higher misclassification error than simply training the basic model, which could be attributed to the fact that adding the prediction networks makes a difficult, high-dimensional optimization problem even harder. As a general trend, adding pre-computed feature embeddings achieved better performance (lower error), while allowing to significantly reduce the number of free parameters in the fat layers of the model. Among the tested feature embeddings, random projections achieved good results, highlighting the potential of the model when reducing the number of free parameters.
+
+Using the SNP2Vec embedding, trained to exploit the similarities and co-occurences between the SNPs, in conjunction with the Diet Networks framework obtains slightly better results than the model using a random projection. The addition of the reconstruction criterion does not appear to reduce the number of errors made by the model but it does appear to reduce the variance of the results, as observed on the other models.
+
+Despite its simplicity, the per class histogram encoding (when used with a reconstruction criterion) yielded the best results. Note that this encoding is the one with the fewest number of free parameters in the fat layers, with a reduction factor of almost 4000 w.r.t. the analogous basic model (with reconstruction). Figure 3(a) shows the mean results obtained with the histogram embedding. As shown in the figure, when considering the ethnicity, the main misclassifications involve ethnicities likely to display very close genetic proximity, such as British from England and Scotland, and Utah residents with Northern and Western ancestry (likely to be immigrants from England), or Indian Telugu and Sri Lankan Tamil for instance. However, the model achieves almost $100 \%$ accuracy when considering the 5 geographical regions.
+
+We also compared the performance of our model to the principal component analysis (PCA) approach, commonly used in the genomics domain, to select subgroups of individuals in order to perform more homogeneous analysis. The number of principal components (PCs) is chosen according to their significance, and usually varies from one dataset to another, being 10 the de facto standard for small datasets. However, in the case of the 1000 Genomes dataset, we could go up to $5 0 \mathrm { P C s }$ . Therefore, we trained a linear classifier on top of PCA features, considering 10 and $5 0 \mathrm { P C s }$ , $1 0 0 \mathrm { P C s }$ to match the number of feature used in the other experiments, as well as $2 0 0 \mathrm { P C s }$ . Using $2 0 0 ~ \mathrm { P C s }$ yielded better performance, but going beyond that saturated in terms of misclassification error (see SectionC in Appendix for more details). Adding hidden layers to the classifier didn’t help either (see reported results for several MLP configurations before the linear classifier).
+
+# 5 CONCLUSION
+
+In this paper, we proposed Diet Networks, a novel network parametrization, which considerably reduces the number of free parameters in the fat layers of a model when the input is very high dimensional. We showed how using the parameter prediction networks, yielded better generalization in terms of misclassification error. Notably, when using pre-computed feature embeddings that maximally reduced the number of free parameters, we were able to obtain our best results. We validated our approach on the publicly available 1000 genomes dataset, addressing the relevant task of ancestry prediction based on SNP data. This work demonstrated the potential of deep learning models to tackle domain-specific tasks where there is a mismatch between the number of samples and their high dimensionality.
+
+Table 1: Results for 1000 Genomes ancestry prediction. Raw end2end, random projection and SNP2Vec embeddings have dimensionality 100, whereas per class histograms has dimensionality 78. Note that the reported number of free parameters corresponds to the free parameters of the fat layers of the models.   
+
+<table><tr><td rowspan=1 colspan=1>Model &amp; Embedding</td><td rowspan=1 colspan=1>MeanMisclassif.Error.(%)</td><td rowspan=1 colspan=1>#of free parameters</td></tr><tr><td rowspan=1 colspan=1>Basic</td><td rowspan=1 colspan=1>8.31 ± 1.83</td><td rowspan=1 colspan=1>31.5M</td></tr><tr><td rowspan=1 colspan=1>Raw end2end</td><td rowspan=1 colspan=1>8.88 ±1.42</td><td rowspan=1 colspan=1>217.2k</td></tr><tr><td rowspan=1 colspan=1>Random Projection</td><td rowspan=1 colspan=1>9.03±1.20</td><td rowspan=1 colspan=1>10.1k</td></tr><tr><td rowspan=1 colspan=1>SNP2Vec</td><td rowspan=1 colspan=1>7.60 ± 1.28</td><td rowspan=1 colspan=1>10.1k</td></tr><tr><td rowspan=1 colspan=1>Per class histograms</td><td rowspan=1 colspan=1>7.88 ± 1.40</td><td rowspan=1 colspan=1>7.9k</td></tr><tr><td rowspan=1 colspan=1>Basic with reconstruction</td><td rowspan=1 colspan=1>7.76 ± 1.38</td><td rowspan=1 colspan=1>63M</td></tr><tr><td rowspan=1 colspan=1>Raw end2end with reconstruction</td><td rowspan=1 colspan=1>8.28 ± 1.92</td><td rowspan=1 colspan=1>227.3k</td></tr><tr><td rowspan=1 colspan=1>Random Projection with reconstruction</td><td rowspan=1 colspan=1>8.03±1.03</td><td rowspan=1 colspan=1>20.2k</td></tr><tr><td rowspan=1 colspan=1>SNP2Vecwith reconstruction</td><td rowspan=1 colspan=1>7.88 ±0.72</td><td rowspan=1 colspan=1>20.2k</td></tr><tr><td rowspan=1 colspan=1>Per class histograms with reconstruction</td><td rowspan=1 colspan=1>7.44 ± 0.45</td><td rowspan=1 colspan=1>15.8k</td></tr><tr><td rowspan=1 colspan=1>Traditionalapproaches</td><td rowspan=1 colspan=2>Mean Misclassif. Error. (%)</td></tr><tr><td rowspan=1 colspan=1>PCA (10 PCs)</td><td rowspan=1 colspan=2>20.56 ± 3.20</td></tr><tr><td rowspan=1 colspan=1>PCA (50 PCs)</td><td rowspan=1 colspan=2>12.29 ± 0.89</td></tr><tr><td rowspan=1 colspan=1>PCA (100 PCs)</td><td rowspan=1 colspan=2>10.52 ± 0.25</td></tr><tr><td rowspan=1 colspan=1>PCA (200 PCs)</td><td rowspan=1 colspan=2>9.33±1.24</td></tr><tr><td rowspan=1 colspan=1>PCA(100 PCs) + MLP(50)</td><td rowspan=1 colspan=2>12.67±0.67</td></tr><tr><td rowspan=1 colspan=1>PCA(100 PCs)+MLP(100)</td><td rowspan=1 colspan=2>12.18 ±1.75</td></tr><tr><td rowspan=1 colspan=1>PCA(100 PCs)+MLP(100,100)</td><td rowspan=1 colspan=2>11.95 ± 2.29</td></tr></table>
+
+Given the high accuracy achieved in the ancestry prediction task, we believe that deep learning techniques can improve standard practices in the analysis of human polymorphism data. We expect that these techniques will allow us to tackle the more challenging problem of conducting genetic association studies. Hence, we expect to further develop our method to conduct population-aware analyses of SNP data in disease cohorts. The increased power of deep learning methods to identify the genetic basis of common diseases could lead to better patient risk prediction and will improve our overall understanding of disease etiology.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank the developers of Theano Theano Development Team (2016) and Lasagne Lasagne (2016). We acknowledge the support of the following agencies for research funding and computing support: Imagia, CIFAR, Canada Research Chairs, Compute Canada and Calcul Quebec. J.G.H. is an EPAC/Linacre Junior Research Fellow funded by the Human Frontiers ´ Program (LT-001017/2013-L). Special thanks to Valeria Romero-Soriano, Xavier Grau-Bov \` e and ´ Margaux Luck for their patience sharing genomic biology expertise; as well as to Michal Drozdzal, Caglar Gulcehre and Simon Jegou for useful discussions and support. ´
+
+# REFERENCES
+
+Babak Alipanahi, Andrew Delong, Matthew T Weirauch, and Brendan J Frey. Predicting the sequence specificities of dna-and rna-binding proteins by deep learning. Nature biotechnology, 2015.
+
+Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W. Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. Technical report, Google DeepMind, 2016.
+
+Y. Bengio, S. Bengio, and J. Cloutier. Learning a synaptic learning rule. 1991 Neural Networks for Computing Conference, Snowbird, 1991.
+
+Luca Bertinetto, Joao F. Henriques, Jack Valmadre, Philip H. S. Torr, and Andrea Vedaldi. Learning ˜ feed-forward one-shot learners. CoRR, abs/1606.05233, 2016.
+
+Ella Bingham and Heikki Mannila. Random projection in dimensionality reduction: Applications to image and text data. In Proceedings of the Seventh ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’01, pp. 245–250. ACM, 2001. doi: 10.1145/ 502512.502546.
+
+Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. CoRR, abs/1605.09673, 2016.
+
+Yifei Chen, Yi Li, Rajiv Narayan, Aravind Subramanian, and Xiaohui Xie. Gene expression inference with deep learning. Bioinformatics, 2016. doi: 10.1093/bioinformatics/btw074.
+
+The 1000 Genomes Project Consortium. A global reference for human genetic variation. Nature, 2015. doi: 10.1038/nature15393.
+
+Misha Denil, Babak Shakibi, Laurent Dinh, Marc’Aurelio Ranzato, and Nando de Freitas. Predicting parameters in deep learning. arXiv:1306.0543, 2013.
+
+Faustino Gomez and Juergen Schmidhuber. Evolving modular fast-weight networks for control. In Proceedings of the Fifteenth International Conference on Artificial Neural Networks: ICANN-05, pp. 383–389, 2005.
+
+David Ha, Andrew Dai, and Quoc V. Le. Hypernetworks. CoRR, abs/1609.09106, 2016.
+
+Ryan J Haasl, Catherine A McCarty, and Bret A Payseur. Genetic ancestry inference using support vector machines, and the active emergence of a unique american population. European Journal of Human Genetics, 2013. doi: 10.1038/ejhg.2012.258.
+
+David R Kelley, Jasper Snoek, and John Rinn. Basset: Learning the regulatory code of the accessible genome with deep convolutional neural networks. bioRxiv, 2016. doi: 10.1101/028399. URL http://biorxiv.org/content/early/2016/02/18/028399.
+
+Lasagne. Lasagne. https://github.com/Lasagne/Lasagne, 2016.
+
+Michael K. K. Leung, Andrew Delong, Babak Alipanahi, and Brendan J. Frey. Machine Learning in Genomic Medicine: A Review of Computational Problems and Data Sets. Proceedings of the IEEE, 104(1):176–197, January 2016. ISSN 0018-9219. doi: 10.1109/jproc.2015.2494198. URL http://dx.doi.org/10.1109/jproc.2015.2494198.
+
+T. Mikolov, I. Sutskever, K. Chen, G.S. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In NIPS’2013, pp. 3111–3119. 2013.
+
+Larsson Omberg, Jacqueline Salit, Neil Hackett, Jennifer Fuller, Rebecca Matthew, Lotfi Chouchane, Juan L Rodriguez-Flores, Carlos Bustamante, Ronald G Crystal, and Jason G Mezey. Inferring genome-wide patterns of admixture in qataris using fifty-five ancestral populations. BMC Genetics, 2012. doi: 10.1186/1471-2156-13-49.
+
+Alkes L Price, Nick J Patterson, Robert M Plenge, Michael E Weinblatt, Nancy A Shadick, and D Reich. Principal components analysis corrects for stratification in genome-wide association studies. Nature Genetics, 2006. doi: 10.1038/ng1847.
+
+Jurgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent ¨ networks. Neural Comput., 4(1):131–139, 1992.
+
+Sara Sheehan and Yun S Song. Deep learning for population genetic inference. PLoS Comput Biol, 2016. doi: 10.1371/journal.pcbi.1004845.
+
+Ritambhara Singh, Jack Lanchantin, Gabriel Robins, and Yanjun Qi. Deepchrome: deep-learning for predicting gene expression from histone modifications. Bioinformatics, 2016. doi: 10.1093/ bioinformatics/btw427.
+
+Kenneth O. Stanley, David B. D’Ambrosio, and Jason Gauci. A hypercube-based encoding for evolving large-scale neural networks. Artif. Life, 15(2):185–212, April 2009.
+
+Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688.
+
+T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012.
+
+Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Andrew McCallum and Sam Roweis (eds.), Proceedings of the 25th Annual International Conference on Machine Learning (ICML 2008), pp. 1096–1103. Omnipress, 2008.
+
+Jian Zhou and Olga Troyanskaya. Predicting effects of noncoding variants with deep learningbased sequence model. Nature Methods, 2015. doi: 10.1038/nmeth.3547.
+
+# A THE 1000 GENOMES PROJECT LEGENDS
+
+A.1 POPULATION ETHNICITY LEGEND
+
+ACB: African Caribbeans in Barbados   
+ASW: Americans of African Ancestry in SW USA   
+BEB: Bengali from Bangladesh   
+CDX: Chinese Dai in Xishuangbanna   
+CEU: Utah Residents (CEPH) with Northern and Western Ancestry   
+CHB: Han Chinese in Bejing   
+CHS: Southern Han Chinese   
+CLM: Colombians from Medellin   
+ESN: Esan in Nigeria   
+FIN: Finnish in Finland   
+GBR: British in England and Scotland   
+GIH: Gujarati Indian from Houston   
+GWD: Gambian in Western Divisions in the Gambia   
+IBS: Iberian Population in Spain   
+ITU: Indian Telugu from the UK   
+JPT: Japanese in Tokyo   
+KHV: Kinh in Ho Chi Minh City   
+LWK: Luhya in Webuye   
+MSL: Mende in Sierra Leone   
+MXL: Mexican Ancestry from Los Angeles   
+PEL: Peruvians from Lima   
+PJL: Punjabi from Lahore   
+PUR: Puerto Ricans   
+STU: Sri Lankan Tamil from the UK   
+TSI: Toscani in Italia   
+YRI: Yoruba in Ibadan
+
+A.2 GEOGPRAHICAL REGION LEGEND
+
+AFR: African   
+AMR: Ad Mixed American   
+EAS: East Asian   
+EUR: European   
+SAS: South Asian
+
+# B OBTAINING THE 1000 GENOMES DATA
+
+SNP data for the 1000G dataset was downloaded from ftp://ftp.1000genomes.ebi.ac. uk:21/vol1/ftp/release/20130502/supporting/hd_genotype_chip/
+
+− ALL . wgs . n h g r i c o r i e l l a f f y 6 . 2 0 1 4 0 8 2 5 . g e n o t y p e s h a s p e d . v c f . g z
+
+− a f f y s a m p l e s . 2 0 1 4 1 1 1 8 . p a n e l
+
+# Representative commands:
+
+With PLINK v1.90b2n 64-bit https://www.cog-genomics.org/plink2
+
+# c o n v e r t v c f t o p l i n k f o r m a t ( b e d ) , a n d o n l y k e e p i n g common m a r k e r s ( m i n o r a l l e l e f r e q u e n c y $>$ 0 . 0 5 i n c o m b i n e d s a m p l e )   
+$>$ p l i n k −−v c f \$ p a t h / ALL . wgs . n h g r i c o r i e l l a f f y 6 . 2 0 1 4 0 8 2 5 . g e n o t y p e s h a s p e d . v c f . g z −−maf 0 . 0 5 −−o u t $\$ 1$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t −−n o t −c h r X Y MT −−make−b e d   
+# p r o d u c e a p r u n e d s u b s e t o f m a r k e r s t h a t a r e i n a p p r o x i m a t e l i n k a g e e q u i l i b r i u m w i t h e a c h o t h e r   
+$>$ p l i n k −− b f i l e \$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t −−i n d e p − p a i r w i s e 50 5 0 . 5 −−o u t $\$ 5$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t   
+# e x c l u d e m a r k e r s t o g e t p r u n e d s u b s e t   
+$>$ p l i n k −− b f i l e \$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t −−e x c l u d e $\$ 9$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t . p r u n e . o u t −−r e c o d e A −− o u t $\$ 5$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 t h i n n e d a u t A
+
+For information on how to download this pre-processed dataset directly, please email Adriana Romero or Pierre Luc Carrier.
+
+# C PCA COMPONENTS AND MISCLASSIFICATION ERROR
+
+In this section, we analyze the influence of increasing the number of PCs used to perform classification. Figure 4 depicts the obtained results when considering 100, 200, 400, 800 and $1 0 0 0 \mathrm { P C s }$ . As shown in the figure, the best validation error comes with PC200. Further increasing the number of PCs improves the training error but does not generalize well on the validation set.
+
+![](images/3c15c086e405ed2263ab05bb546dd4339ac37174db86a7f53d642a5af2568ee2.jpg)  
+Figure 4: PCA: Train and validation misclassification error for different numbers of PCs.

parse/train/Sk-oDY9ge/Sk-oDY9ge_content_list.json

@@ -0,0 +1,1327 @@
+[
+    {
+        "type": "text",
+        "text": "DIET NETWORKS: THIN PARAMETERS FOR FAT GENOMICS ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            98,
+            689,
+            145
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Adriana Romero∗, Pierre Luc Carrier∗, Akram Erraqabi, Tristan Sylvain, Alex Auvolat, Etienne Dejoie ",
+        "bbox": [
+            184,
+            170,
+            452,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Montreal Institute for Learning Algorithms Montreal, Quebec, Canada firstName.lastName@umontreal.ca, except adriana.romero.soriano@umontreal.ca and pierre-luc.carrier@umontreal.ca ",
+        "bbox": [
+            184,
+            213,
+            524,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Marc-Andre Legault ´ 1, Marie-Pierre Dube´1,2,3 ",
+        "text_level": 1,
+        "bbox": [
+            545,
+            170,
+            867,
+            184
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1University of Montreal, Faculty of Medicine   \n2Montreal Heart Institute,   \n3Beaulieu-Saucier Pharmacogenomics Centre   \nMontreal, Quebec, Canada   \nmarc-andre.legault.1@umontreal.ca   \nmarie-pierre.dube@umontreal.ca ",
+        "bbox": [
+            545,
+            185,
+            867,
+            268
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Julie G. Hussin ",
+        "text_level": 1,
+        "bbox": [
+            184,
+            303,
+            292,
+            315
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Wellcome Trust Centre for Human Genetics   \nUniversity of Oxford   \nOxford, UK   \njulieh@well.ox.ac.uk ",
+        "bbox": [
+            184,
+            318,
+            472,
+            371
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Yoshua Bengio ",
+        "text_level": 1,
+        "bbox": [
+            511,
+            303,
+            614,
+            316
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Montreal Institute for Learning Algorithms Montreal, Quebec, Canada yoshua.umontreal@gmail.com ",
+        "bbox": [
+            511,
+            318,
+            794,
+            358
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            410,
+            544,
+            424
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Learning tasks such as those involving genomic data often poses a serious challenge: the number of input features can be orders of magnitude larger than the number of training examples, making it difficult to avoid overfitting, even when using the known regularization techniques. We focus here on tasks in which the input is a description of the genetic variation specific to a patient, the single nucleotide polymorphisms (SNPs), yielding millions of ternary inputs. Improving the ability of deep learning to handle such datasets could have an important impact in medical research, more specifically in precision medicine, where highdimensional data regarding a particular patient is used to make predictions of interest. Even though the amount of data for such tasks is increasing, this mismatch between the number of examples and the number of inputs remains a concern. Naive implementations of classifier neural networks involve a huge number of free parameters in their first layer (number of input features times number of hidden units): each input feature is associated with as many parameters as there are hidden units. We propose a novel neural network parametrization which considerably reduces the number of free parameters. It is based on the idea that we can first learn or provide a distributed representation for each input feature (e.g. for each position in the genome where variations are observed in data), and then learn (with another neural network called the parameter prediction network) how to map a feature’s distributed representation (based on the feature’s identity not its value) to the vector of parameters specific to that feature in the classifier neural network (the weights which link the value of the feature to each of the hidden units). This approach views the problem of producing the parameters associated with each feature as a multi-task learning problem. We show experimentally on a population stratification task of interest to medical studies that the proposed approach can significantly reduce both the number of parameters and the error rate of the classifier. ",
+        "bbox": [
+            232,
+            441,
+            764,
+            813
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            336,
+            857
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Medical datasets often involve a dire imbalance between the number of training examples and the number of input features, especially when genomic information is used as input to the trained predictor. This is problematic in the context where we want to apply deep learning (which typically involves large models) to precision medicine, i.e., making patient-specific predictions using a potentially large set of input features to better characterize the patient. This paper proposes a novel approach, called Diet Networks, to reparametrize neural networks to considerably reduce their number of free parameters when the input is very high-dimensional and orders of magnitude larger than the number of training examples. ",
+        "bbox": [
+            176,
+            873,
+            823,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            188
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Genomics is the study of the genetic code encapsulated as DNA in all living organisms’ cells. Genomes contain the instructions to produce and regulate all the functional components needed to guide the development and adaptation of living organisms. In the last decades, advances in genomic technologies resulted in an explosion of available data, making it more interesting to apply advanced machine learning techniques such as deep learning. Learning tasks involving genomic data and already tackled by deep learning include: using Convolutional Neural Networks (CNNs) to learn the functional activity of DNA sequences (Basset package, Kelley et al. (2016), predicting effects of noncoding DNA (DeepSEA, Zhou & Troyanskaya (2015)), investigating the regulatory role of RNA binding proteins in alternative splicing (Alipanahi et al., 2015), inferring gene expression patterns (Chen et al., 2016; Singh et al., 2016) and population genetic parameters (Sheehan & Song, 2016) among others (see Leung et al. (2016) for a detailed example). Noticeably, most of these techniques are based on sequence data where convolutional or recurrent networks are appropriate. When the full DNA sequence is unavailable, such as when data is acquired through genotyping, other methods need to be used. All this work shows that deep learning can be used to tackle genomic-related tasks, paving the road towards a better understanding of the biological impact of DNA variation. ",
+        "bbox": [
+            174,
+            194,
+            825,
+            401
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Applying deep learning to human genetic variation holds the promise of identifying individuals at risk for medical conditions. Modern genotyping technologies usually target millions of simple variants across the genome, called single nucleotide polymorphisms (SNPs). These genetic mutations result from substitutions from one nucleotide to another (eg. A to C), where both versions exist within a population. In modern studies, as many as 5 millions SNPs can be acquired for every participant. These datasets differ from other types of genomic data because they focus on the genetic differences between individuals which represents a space of high dimensionality where sequencecontext information is unavailable. In medical genetics, these variants are tested for their association with a trait of interest, an approach termed genome-wide association study (GWAS). This methodology aims at finding genetic variants implicated in disease susceptibility, etiology and treatment. ",
+        "bbox": [
+            174,
+            410,
+            825,
+            549
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "An important confounding factor in GWAS is population stratification, which arises because both disease prevalence and genetic profiles vary from one population to the other. Although most GWAS have been restricted to homogeneous populations, dimensionality reduction techniques are generally used to account for population-level genetic differences (Price et al., 2006). Our experiments compare such dimensionality reduction techniques (based on principal components analysis, PCA) to the proposed Diet Network parametrization, as well as with standard deep networks. ",
+        "bbox": [
+            174,
+            555,
+            823,
+            638
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, several machine learning methods have been successfully applied to detect population stratification, based on the presence of systematic differences in genetic variation between populations. For instance, Support Vector Machines (SVM) models have been used multiple times to infer recent genetic ancestry of sub-continental populations (Haasl et al. (2013)), and local ancestry in admixed populations (SupportMix, Omberg et al. (2012), 23andMe, Inc.). However SVM methods are very sensitive to the the kernel choice and the parameters. They also tend to overfit the model selection criterion which usually induces a limitation in its predictive power. ",
+        "bbox": [
+            174,
+            646,
+            823,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this work, we are interested in predicting the genetic ancestry of an individual from their SNP data using a novel deep learning approach, Diet Networks, which allow us to considerably reduce the number of free parameters. Therefore, we propose to tackle this problem by introducing a multi-task architecture in which the problem of predicting the appropriate parameters for each input feature is considered like a task in itself, and the same parameter prediction network is used for all of the hundreds of thousands of input features. This parameter prediction network learns to predict these feature-specific parameters as a function of a distributed representation of the feature identity, or feature embedding. The feature embedding can be learned as part of end-to-end training or using other datasets or a priori knowledge about the features. What is important is that two features which are similar in some appropriate sense (in terms of their interactions with other features or other variables observed in any dataset) end up having similar embeddings, and thus a similar parameter vector as output of the parameter prediction network. A practical advantage of this approach is that the parameter prediction network can generalize to new features for which there is no labeled training data (without the target to be predicted by the classifier), so long as it is possible to derive an embedding for that feature (for example using just the unlabeled observations of co-occurences of that feature with other features in human genomes). ",
+        "bbox": [
+            174,
+            751,
+            825,
+            916
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            823,
+            159
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "An interesting consideration is that from the point of the parameter prediction network, each feature is an example: more features now allow to better train the parameter prediction network. It is like if we were considering not the data matrix itself but its transpose. This is actually how the Diet Network implementation processes the data, by using the transpose of the matrix of input values as the input part of the learning task for the parameter prediction network. ",
+        "bbox": [
+            174,
+            166,
+            825,
+            236
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The idea of having two networks interacting with each other and with one producing parameters for the other is well rooted in the machine learning literature (Bengio et al., 1991; Schmidhuber, 1992; Gomez & Schmidhuber, 2005; Stanley et al., 2009; Denil et al., 2013; Andrychowicz et al., 2016). Recent efforts in the same direction include works such as (Bertinetto et al., 2016; Brabandere et al., 2016; Ha et al., 2016) that use a network to predict the parameters of a Convolutional Neural Network (CNN). Brabandere et al. (2016) introduce a dynamic filter module that generates network filters conditioned on an input. Bertinetto et al. (2016) propose to learn the parameters of a deep model in one shot, by training a second network to predict the parameters of the first from a single exemplar. Hypernetworks (Ha et al., 2016) explore the idea of using a small network to predict the parameters of another network, training them in an end-to-end fashion. The small network takes as input the feature embedding from the previous layer and learns the parameters of the current layer. ",
+        "bbox": [
+            174,
+            242,
+            825,
+            396
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "To the best of our knowledge, deep learning has never been used so far to tackle the problem of ancestry prediction based on SNP data. Compared to other approaches that attempt to learn model parameters using a parameter prediction network, our main goal is to reduce the large number of parameters required by the model, by considering the input features themselves as sub-tasks in a multi-task view of the learning problem, as opposed to constructing a model with even higher capacity, as seen, e.g. in (Ha et al., 2016). Our approach is thus based on building an embedding of these tasks (the features) in order to further reduce the number of parameters. ",
+        "bbox": [
+            174,
+            404,
+            825,
+            501
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We evaluate our method on a publicly available dataset for ancestry prediction, the 1000 Genomes dataset1, that best represents the human population diversity. Because population-specific differences in disease and drug response are widespread, identifying an individual’s ancestry heritage based on SNP data is a very important task to help detect biological causation and achieve good predictive performance in precision medicine. Most importantly, ancestry-aware approaches in precision genomics will reduce the hidden risks of genetic testing, by preventing spurious diagnosis and ineffective treatment. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2 METHOD ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            627,
+            282,
+            643
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the Diet Networks as well as the feature embeddings used by the model. ",
+        "bbox": [
+            173,
+            660,
+            821,
+            674
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1 MODEL ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            694,
+            267,
+            708
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Our model aims at reducing the number of free parameters that a network trained on fat data would typically have. ",
+        "bbox": [
+            176,
+            720,
+            823,
+            750
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Let $\\mathbf { X } \\in \\mathbb { R } ^ { N \\times N _ { d } }$ be a matrix of data, with $N$ samples and $N _ { d }$ features, where $N \\ll N _ { d }$ (e. g. $N$ being approximately 100 times smaller than $N _ { d . }$ ). We build a multi-layer perceptron (MLP), which takes $\\mathbf { X }$ as input, computes a hidden representation and outputs a prediction $\\hat { \\mathbf Y }$ . Optionally, the MLP may generate a reconstruction $\\hat { \\mathbf X }$ of the input data from the hidden representation. Figure 1(a) illustrates this basic network architecture. Let $\\mathbf { x _ { i } }$ be one data sample, i.e. a row in $\\mathbf { X }$ . The standard formulations to compute its hidden representation $\\mathbf { h _ { i } }$ , output prediction $\\hat { \\mathbf { y } } _ { \\mathbf { i } }$ and reconstruction $\\hat { \\bf x } _ { \\bf i }$ are given by ",
+        "bbox": [
+            173,
+            756,
+            825,
+            858
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/279880e9472ecab186a8e02cdae756ba9c190fad866ea883db6a87b746af98de.jpg",
+        "text": "$$\n\\mathbf { h _ { i } } = f ( \\mathbf { x _ { i } } ) , \\quad \\hat { \\mathbf { y _ { i } } } = g ( \\mathbf { h _ { i } } ) , \\quad \\hat { \\mathbf { x _ { i } } } = r ( \\mathbf { h _ { i } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            859,
+            633,
+            876
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $f , g$ and $r$ are non-linear functions. ",
+        "bbox": [
+            174,
+            882,
+            449,
+            897
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/5a4c7493d56a4be3b5a2927448f69fa77c0f63af1cd91a8b998d8317bc19d848.jpg",
+        "image_caption": [
+            "Figure 1: Our model is composed of 3 networks, one basic and two auxiliary networks: (a) a basic discriminative network with optional reconstruction path (dashed arrow), (b) a network that predicts the input fat layer parameters, and (c) a network that predicts the reconstruction fat layer parameters (if any). First layer in the ”prediction networks” (b, c) represents embedding (Emb.). Each MLP block may contain any number of hidden layers. ${ \\bf W _ { e } }$ and $\\mathbf { \\hat { W } _ { d } ^ { T } }$ represent the parameters of the fat hidden layer and the fat reconstruction layer of the basic network (a), respectively. These parameters are predicted by auxiliary networks (b) and (c) – also called parameter prediction networks – to reduce the number of free parameters of (a). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            299,
+            108,
+            704,
+            290
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The number of parameters of the first hidden layer of the architecture grows linearly with the dimensionality of the input data: ",
+        "bbox": [
+            173,
+            444,
+            821,
+            472
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/61a61509566409f759316f2a8d89ce8e19860afc4c2d075cbc7607f15ef6b1dc.jpg",
+        "text": "$$\n\\mathbf { h _ { i } ^ { ( 1 ) } } = f _ { 1 } ( \\mathbf { x _ { i } } \\mathbf { W _ { e } } + \\mathbf { b _ { e } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            469,
+            580,
+            491
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where ${ \\bf W _ { e } }$ and $\\mathbf { b _ { e } }$ are the layer’s parameters. Using fat data such as the one described in Section 1, leads to a parameter explosion in this layer, hereafter referred to as fat hidden layer. To give the reader an intuition, consider the case of having an input with $N _ { d } = 3 0 0 K$ , and a hidden layer with $N _ { h } ^ { 1 } = 1 0 0$ , the number of parameters of such a layer would be 30M. The same happens to the number of parameters of the optional reconstruction layer, hereafter referred to as fat reconstruction layer. ",
+        "bbox": [
+            173,
+            493,
+            825,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In order to mitigate this effect, we introduce an auxiliary network to predict the fat layers’ parameters. The auxiliary network takes as input the transposed data matrix $\\mathbf { X ^ { \\mathrm { T } } }$ , extracts a feature embedding and learns a function of this embedding, to be used as parameters of a fat layer: ",
+        "bbox": [
+            174,
+            583,
+            825,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/71494a94b2754cda75a8e54e1fdff91daafc15632bdd3309ed641819d383fcb6.jpg",
+        "text": "$$\n( \\mathbf { W _ { e } } ) _ { \\mathbf { j } : } = \\phi ( \\mathbf { e _ { j } } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            439,
+            633,
+            553,
+            652
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbf { e _ { j } }$ represents the embedding of a feature in $\\mathbf { X ^ { \\mathrm { T } } }$ , $\\phi$ is a non-linear function and $( \\mathbf { W _ { e } } ) _ { \\mathbf { j } : }$ is the $j$ -th row of ${ \\bf W _ { e } }$ . This means that each feature is associated with the vector of values it takes in the dataset (e.g. across the patients). Other representations could be used, e.g., derived from other datasets in which those features interact. Figure 1(b) shows a prediction network which is an auxiliary network that predicts the parameters of the fat hidden layer of our basic network. Following the same spirit, Figure 1(c) highlights the interaction between a second prediction network that predicts the fat reconstruction layer parameters and the basic network. The architectures of both auxiliary networks may share the initial feature embedding. ",
+        "bbox": [
+            173,
+            659,
+            825,
+            773
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The feature embeddings used in the auxiliary networks allow us to substantially reduce the number of free parameters of the fat layers of the basic architecture. The auxiliary network should predict a matrix of weights of size $N _ { d } \\times N _ { h } ^ { 1 }$ from a feature embedding. Consider a feature embedding that would transform each $N$ -dimensional feature into a $N _ { f }$ -dimensional vector, where $N _ { f } < N$ . The auxiliary network would learn a function $\\phi : \\mathcal { R } ^ { N _ { f } }  \\mathbb { R } ^ { N _ { h } ^ { 1 } }$ . Thus, the fat hidden layer of our basic architecture would have $N _ { f } \\times N _ { h } ^ { 1 }$ free parameters (assuming a single layer MLP in the auxiliary network), instead of $N _ { d } \\times N _ { h } ^ { 1 }$ . Following our previous example, where $N _ { d } = 3 0 0 K$ and $N _ { h } ^ { 1 } = 1 0 0$ , using an auxiliary network with previously-obtained feature embeddings of dimensionality $N _ { f } =$ 500 would reduce the number of free parameters of the basic network by a factor of 600 (from 30M to 50K). ",
+        "bbox": [
+            173,
+            780,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The model is trained end-to-end by minimizing the following objective function ",
+        "bbox": [
+            173,
+            103,
+            697,
+            118
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/0724cce3cf6ed1d208e95b07cb95307d38389db714a8bb2449266ac588d6f202.jpg",
+        "text": "$$\n\\mathcal { H } ( \\hat { \\mathbf { Y } } , \\mathbf { Y } ) + \\gamma | | \\hat { \\mathbf { X } } - \\mathbf { X } | | _ { 2 } ^ { 2 } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            410,
+            125,
+            583,
+            145
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathcal { H }$ refers to the cross-entropy, $\\mathbf { Y }$ to the true classification labels and $\\gamma$ is a tunable parameter to balance the supervised and the reconstruction losses. ",
+        "bbox": [
+            171,
+            151,
+            823,
+            180
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.2 FEATURE EMBEDDINGS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            196,
+            377,
+            212
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The feature embeddings used by the auxiliary networks can be either pre-computed or learnt offline, as well as learnt jointly with the rest of the architecture. In theory, any kind of embedding could be used, as long as we keep in mind that the goal is to reduce the number of free parameters of the basic model. In this work, we considered random projections (Bingham & Mannila, 2001), histograms (which are akin to bag-of-words representations), feature embeddings learnt offline (Mikolov et al., 2013) and feature embeddings jointly learnt with the rest of the proposed architecture. ",
+        "bbox": [
+            174,
+            223,
+            825,
+            308
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Random projection: Randomly initializing an MLP defines a random projection. By using such a projection to encode the high-dimensional feature space into a more manageable lower-dimensional space, we were able to obtain decent results. ",
+        "bbox": [
+            176,
+            314,
+            821,
+            356
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Per class histogram: For a given SNP, we can define a histogram of the values it can take over the whole population. Once normalized, this yields 3 values per SNP, corresponding to the proportion of the population having the values 0, 1 and 2 respectively for that SNP. After initial tests showed this was too coarse a representation for the dataset, we instead chose to consider the per-class proportion of the three values. With 26 classes in the 1000 Genomes dataset, this yields an embedding of size 78 for each feature. By this method, the matrix $\\mathbf { X ^ { \\mathrm { T } } }$ is summarized as a $N _ { d } \\times 7 8$ matrix, where $N _ { d }$ is the number of SNPs in the dataset. ",
+        "bbox": [
+            174,
+            363,
+            825,
+            460
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "SNPtoVec: In Mikolov et al. (2013), the authors propose a word embedding that allows good reconstruction of the words’ context (surrounding words) by a neural network. SNPs do not have a similarly well-defined positional context (SNPs close together in our ordering might very well be independent) so our embedding is instead built by training a denoising autoencoder (DAE) (Vincent et al., 2008) on the matrix X. Thus, the DAE learns to recover the values of missing SNPs by leveraging their similarities and cooccurences with other SNPs. Once the DAE is trained, we obtain an encoding for each feature by feeding to the DAE an input where only that feature is active (the other features are set to 0s) and computing the hidden representation of the autoencoder for that single-feature input. ",
+        "bbox": [
+            173,
+            467,
+            825,
+            593
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Embedding learnt end-to-end from raw data: In this case, we consider the feature embedding to be another MLP, whose input corresponds to the values that a SNP takes for each of the training samples and, whose parameters are learnt jointly with the rest of the network. Note that the layer(s) corresponding to the feature embedding are shared among auxiliary networks. For experiments reported in Section 4, we used a single hidden layer as embedding. ",
+        "bbox": [
+            174,
+            599,
+            825,
+            670
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 DATA: THE 1000 GENOMES PROJECT ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            689,
+            517,
+            707
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The 1000 Genomes project is the first project to sequence the genomes of a large number of people in populations worldwide, yielding the largest public catalog of human genetic variants to date Consortium (2015). This allowed large-scale comparison of DNA sequences from populations, thanks to the presence of genetic variation. Individuals of the 1000 Genomes project are samples taken from 26 populations over the world, which are grouped into 5 geographical regions. Figure 2(a) shows a histogram derived from the 1000 Genomes data, depicting the frequency of individuals per population (ethnicity). Analogously, Figure 2(b) depicts the frequency of individuals per geographical region. ",
+        "bbox": [
+            174,
+            722,
+            825,
+            833
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In this dataset, we included 315,345 genetic variants with frequencies of at least $5 \\%$ in 3,450 individuals sampled worldwide from 26 populations, interrogated using microarray genotyping technology: the Genome-Wide Human SNP Array 6.0 by Affymetrix. The mutated state is established by comparison to the Genome Reference Consortium human genome (build 37). Since individuals have 2 copies of each genomic position, a sampled individual can have 0, 1 or 2 copies of a genetic mutation, hereafter referred to as an individual genotype. We excluded SNPs positioned on the sex chromosomes and only included SNPs in approximate linkage equilibrium with each other, such that genotypes at neighboring positions are only weakly correlated $( r ^ { 2 } < 0 . 5 )$ . ",
+        "bbox": [
+            174,
+            840,
+            823,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/09ea8294618b9993a70f96d30ca2f1331641175c150a60f545d07b117b6f0da7.jpg",
+        "image_caption": [
+            "Figure 2: The 1000 Genomes population distribution:(a) Ethnicity; (b) Geographical Region. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            151,
+            823,
+            395
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            453,
+            326,
+            469
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe the model architectures, and report and discuss the obtained results. ",
+        "bbox": [
+            171,
+            484,
+            799,
+            500
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/0ccd4f6db366387a241d01be92e4ff7d2439249520117517a01010e0b34e0731.jpg",
+        "image_caption": [
+            "Figure 3: Results of our best model: (a) Confusion matrix per ethnicity; (b) Confusion matrix per large geographical region. The 1000 Genomes legend for population abbreviations can be found in the appendix. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            539,
+            818,
+            787
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.1 MODEL ARCHITECTURE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            869,
+            383,
+            883
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We experimented with simple models both in the auxiliary networks and the basic architecture, which yielded very promising results. We designed a basic architecture with 2 hidden layers followed by a softmax layer to perform ancestry prediction. We trained this architecture with and without the assistance of the auxiliary network. Similarly, the auxiliary networks were build by stacking a hidden layer on top of one of the feature embeddings described in Section 2.2. In the reported experiments, all hidden layers have 100 units. All models were trained by means of stochastic gradient descent with adaptive learning rate (Tieleman & Hinton, 2012), both for $\\gamma = 0$ and $\\gamma = 1 0$ , using dropout, limiting the norm of the weights to 1 and/or applying weight decay to reduce overfitting.2. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            103,
+            825,
+            188
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.2 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            204,
+            277,
+            218
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Given the relatively small amount of samples in the 1000 Genomes data, we report results obtained by 5-fold cross validation of the model. We split the data into 5 folds of equal size. A single fold is retained for test, whereas three of the remaining folds are used as training data and the final fold is used as validation data. We repeated the process 5 times (one per fold) and report the means and standard deviations of results on the different test sets. ",
+        "bbox": [
+            174,
+            229,
+            825,
+            299
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Table 1 summarizes the results obtained for each model. First, we observe that, for most of Diet Network architectures, training with an reconstruction term in the loss $( \\gamma > 0 )$ ) reduces the misclassification error and provides a lower standard deviation over the folds, suggesting more robustness to variations in the learnt feature embedding. ",
+        "bbox": [
+            174,
+            306,
+            823,
+            362
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Training the models end-to-end, with no pre-computed feature embedding, yielded higher misclassification error than simply training the basic model, which could be attributed to the fact that adding the prediction networks makes a difficult, high-dimensional optimization problem even harder. As a general trend, adding pre-computed feature embeddings achieved better performance (lower error), while allowing to significantly reduce the number of free parameters in the fat layers of the model. Among the tested feature embeddings, random projections achieved good results, highlighting the potential of the model when reducing the number of free parameters. ",
+        "bbox": [
+            174,
+            369,
+            825,
+            467
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Using the SNP2Vec embedding, trained to exploit the similarities and co-occurences between the SNPs, in conjunction with the Diet Networks framework obtains slightly better results than the model using a random projection. The addition of the reconstruction criterion does not appear to reduce the number of errors made by the model but it does appear to reduce the variance of the results, as observed on the other models. ",
+        "bbox": [
+            174,
+            474,
+            825,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Despite its simplicity, the per class histogram encoding (when used with a reconstruction criterion) yielded the best results. Note that this encoding is the one with the fewest number of free parameters in the fat layers, with a reduction factor of almost 4000 w.r.t. the analogous basic model (with reconstruction). Figure 3(a) shows the mean results obtained with the histogram embedding. As shown in the figure, when considering the ethnicity, the main misclassifications involve ethnicities likely to display very close genetic proximity, such as British from England and Scotland, and Utah residents with Northern and Western ancestry (likely to be immigrants from England), or Indian Telugu and Sri Lankan Tamil for instance. However, the model achieves almost $100 \\%$ accuracy when considering the 5 geographical regions. ",
+        "bbox": [
+            173,
+            550,
+            825,
+            676
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We also compared the performance of our model to the principal component analysis (PCA) approach, commonly used in the genomics domain, to select subgroups of individuals in order to perform more homogeneous analysis. The number of principal components (PCs) is chosen according to their significance, and usually varies from one dataset to another, being 10 the de facto standard for small datasets. However, in the case of the 1000 Genomes dataset, we could go up to $5 0 \\mathrm { P C s }$ . Therefore, we trained a linear classifier on top of PCA features, considering 10 and $5 0 \\mathrm { P C s }$ , $1 0 0 \\mathrm { P C s }$ to match the number of feature used in the other experiments, as well as $2 0 0 \\mathrm { P C s }$ . Using $2 0 0 ~ \\mathrm { P C s }$ yielded better performance, but going beyond that saturated in terms of misclassification error (see SectionC in Appendix for more details). Adding hidden layers to the classifier didn’t help either (see reported results for several MLP configurations before the linear classifier). ",
+        "bbox": [
+            173,
+            683,
+            825,
+            821
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            842,
+            318,
+            857
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we proposed Diet Networks, a novel network parametrization, which considerably reduces the number of free parameters in the fat layers of a model when the input is very high dimensional. We showed how using the parameter prediction networks, yielded better generalization in terms of misclassification error. Notably, when using pre-computed feature embeddings that maximally reduced the number of free parameters, we were able to obtain our best results. We validated our approach on the publicly available 1000 genomes dataset, addressing the relevant task of ancestry prediction based on SNP data. This work demonstrated the potential of deep learning models to tackle domain-specific tasks where there is a mismatch between the number of samples and their high dimensionality. ",
+        "bbox": [
+            176,
+            872,
+            823,
+            901
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/2cb0c7d29b8dea9e5cae08b995d53ee567389dddc319a6317a4231e53fe1835b.jpg",
+        "table_caption": [
+            "Table 1: Results for 1000 Genomes ancestry prediction. Raw end2end, random projection and SNP2Vec embeddings have dimensionality 100, whereas per class histograms has dimensionality 78. Note that the reported number of free parameters corresponds to the free parameters of the fat layers of the models. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Model &amp; Embedding</td><td rowspan=1 colspan=1>MeanMisclassif.Error.(%)</td><td rowspan=1 colspan=1>#of free parameters</td></tr><tr><td rowspan=1 colspan=1>Basic</td><td rowspan=1 colspan=1>8.31 ± 1.83</td><td rowspan=1 colspan=1>31.5M</td></tr><tr><td rowspan=1 colspan=1>Raw end2end</td><td rowspan=1 colspan=1>8.88 ±1.42</td><td rowspan=1 colspan=1>217.2k</td></tr><tr><td rowspan=1 colspan=1>Random Projection</td><td rowspan=1 colspan=1>9.03±1.20</td><td rowspan=1 colspan=1>10.1k</td></tr><tr><td rowspan=1 colspan=1>SNP2Vec</td><td rowspan=1 colspan=1>7.60 ± 1.28</td><td rowspan=1 colspan=1>10.1k</td></tr><tr><td rowspan=1 colspan=1>Per class histograms</td><td rowspan=1 colspan=1>7.88 ± 1.40</td><td rowspan=1 colspan=1>7.9k</td></tr><tr><td rowspan=1 colspan=1>Basic with reconstruction</td><td rowspan=1 colspan=1>7.76 ± 1.38</td><td rowspan=1 colspan=1>63M</td></tr><tr><td rowspan=1 colspan=1>Raw end2end with reconstruction</td><td rowspan=1 colspan=1>8.28 ± 1.92</td><td rowspan=1 colspan=1>227.3k</td></tr><tr><td rowspan=1 colspan=1>Random Projection with reconstruction</td><td rowspan=1 colspan=1>8.03±1.03</td><td rowspan=1 colspan=1>20.2k</td></tr><tr><td rowspan=1 colspan=1>SNP2Vecwith reconstruction</td><td rowspan=1 colspan=1>7.88 ±0.72</td><td rowspan=1 colspan=1>20.2k</td></tr><tr><td rowspan=1 colspan=1>Per class histograms with reconstruction</td><td rowspan=1 colspan=1>7.44 ± 0.45</td><td rowspan=1 colspan=1>15.8k</td></tr><tr><td rowspan=1 colspan=1>Traditionalapproaches</td><td rowspan=1 colspan=2>Mean Misclassif. Error. (%)</td></tr><tr><td rowspan=1 colspan=1>PCA (10 PCs)</td><td rowspan=1 colspan=2>20.56 ± 3.20</td></tr><tr><td rowspan=1 colspan=1>PCA (50 PCs)</td><td rowspan=1 colspan=2>12.29 ± 0.89</td></tr><tr><td rowspan=1 colspan=1>PCA (100 PCs)</td><td rowspan=1 colspan=2>10.52 ± 0.25</td></tr><tr><td rowspan=1 colspan=1>PCA (200 PCs)</td><td rowspan=1 colspan=2>9.33±1.24</td></tr><tr><td rowspan=1 colspan=1>PCA(100 PCs) + MLP(50)</td><td rowspan=1 colspan=2>12.67±0.67</td></tr><tr><td rowspan=1 colspan=1>PCA(100 PCs)+MLP(100)</td><td rowspan=1 colspan=2>12.18 ±1.75</td></tr><tr><td rowspan=1 colspan=1>PCA(100 PCs)+MLP(100,100)</td><td rowspan=1 colspan=2>11.95 ± 2.29</td></tr></table>",
+        "bbox": [
+            196,
+            101,
+            802,
+            357
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            448,
+            825,
+            545
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Given the high accuracy achieved in the ancestry prediction task, we believe that deep learning techniques can improve standard practices in the analysis of human polymorphism data. We expect that these techniques will allow us to tackle the more challenging problem of conducting genetic association studies. Hence, we expect to further develop our method to conduct population-aware analyses of SNP data in disease cohorts. The increased power of deep learning methods to identify the genetic basis of common diseases could lead to better patient risk prediction and will improve our overall understanding of disease etiology. ",
+        "bbox": [
+            174,
+            553,
+            825,
+            650
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            666,
+            326,
+            679
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The authors would like to thank the developers of Theano Theano Development Team (2016) and Lasagne Lasagne (2016). We acknowledge the support of the following agencies for research funding and computing support: Imagia, CIFAR, Canada Research Chairs, Compute Canada and Calcul Quebec. J.G.H. is an EPAC/Linacre Junior Research Fellow funded by the Human Frontiers ´ Program (LT-001017/2013-L). Special thanks to Valeria Romero-Soriano, Xavier Grau-Bov \\` e and ´ Margaux Luck for their patience sharing genomic biology expertise; as well as to Michal Drozdzal, Caglar Gulcehre and Simon Jegou for useful discussions and support. ´ ",
+        "bbox": [
+            174,
+            689,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            808,
+            285,
+            823
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Babak Alipanahi, Andrew Delong, Matthew T Weirauch, and Brendan J Frey. Predicting the sequence specificities of dna-and rna-binding proteins by deep learning. Nature biotechnology, 2015. ",
+        "bbox": [
+            176,
+            830,
+            821,
+            872
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Marcin Andrychowicz, Misha Denil, Sergio Gomez, Matthew W. Hoffman, David Pfau, Tom Schaul, and Nando de Freitas. Learning to learn by gradient descent by gradient descent. Technical report, Google DeepMind, 2016. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Y. Bengio, S. Bengio, and J. Cloutier. Learning a synaptic learning rule. 1991 Neural Networks for Computing Conference, Snowbird, 1991. ",
+        "bbox": [
+            171,
+            103,
+            825,
+            132
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Luca Bertinetto, Joao F. Henriques, Jack Valmadre, Philip H. S. Torr, and Andrea Vedaldi. Learning ˜ feed-forward one-shot learners. CoRR, abs/1606.05233, 2016. ",
+        "bbox": [
+            173,
+            140,
+            823,
+            170
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ella Bingham and Heikki Mannila. Random projection in dimensionality reduction: Applications to image and text data. In Proceedings of the Seventh ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’01, pp. 245–250. ACM, 2001. doi: 10.1145/ 502512.502546. ",
+        "bbox": [
+            173,
+            176,
+            825,
+            233
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Bert De Brabandere, Xu Jia, Tinne Tuytelaars, and Luc Van Gool. Dynamic filter networks. CoRR, abs/1605.09673, 2016. ",
+        "bbox": [
+            173,
+            242,
+            825,
+            271
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Yifei Chen, Yi Li, Rajiv Narayan, Aravind Subramanian, and Xiaohui Xie. Gene expression inference with deep learning. Bioinformatics, 2016. doi: 10.1093/bioinformatics/btw074. ",
+        "bbox": [
+            173,
+            279,
+            823,
+            309
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The 1000 Genomes Project Consortium. A global reference for human genetic variation. Nature, 2015. doi: 10.1038/nature15393. ",
+        "bbox": [
+            173,
+            315,
+            823,
+            345
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Misha Denil, Babak Shakibi, Laurent Dinh, Marc’Aurelio Ranzato, and Nando de Freitas. Predicting parameters in deep learning. arXiv:1306.0543, 2013. ",
+        "bbox": [
+            171,
+            353,
+            823,
+            383
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Faustino Gomez and Juergen Schmidhuber. Evolving modular fast-weight networks for control. In Proceedings of the Fifteenth International Conference on Artificial Neural Networks: ICANN-05, pp. 383–389, 2005. ",
+        "bbox": [
+            173,
+            390,
+            825,
+            433
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David Ha, Andrew Dai, and Quoc V. Le. Hypernetworks. CoRR, abs/1609.09106, 2016. ",
+        "bbox": [
+            174,
+            440,
+            753,
+            457
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ryan J Haasl, Catherine A McCarty, and Bret A Payseur. Genetic ancestry inference using support vector machines, and the active emergence of a unique american population. European Journal of Human Genetics, 2013. doi: 10.1038/ejhg.2012.258. ",
+        "bbox": [
+            174,
+            464,
+            826,
+            508
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "David R Kelley, Jasper Snoek, and John Rinn. Basset: Learning the regulatory code of the accessible genome with deep convolutional neural networks. bioRxiv, 2016. doi: 10.1101/028399. URL http://biorxiv.org/content/early/2016/02/18/028399. ",
+        "bbox": [
+            173,
+            515,
+            821,
+            559
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Lasagne. Lasagne. https://github.com/Lasagne/Lasagne, 2016. ",
+        "bbox": [
+            173,
+            566,
+            681,
+            582
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Michael K. K. Leung, Andrew Delong, Babak Alipanahi, and Brendan J. Frey. Machine Learning in Genomic Medicine: A Review of Computational Problems and Data Sets. Proceedings of the IEEE, 104(1):176–197, January 2016. ISSN 0018-9219. doi: 10.1109/jproc.2015.2494198. URL http://dx.doi.org/10.1109/jproc.2015.2494198. ",
+        "bbox": [
+            173,
+            589,
+            825,
+            646
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "T. Mikolov, I. Sutskever, K. Chen, G.S. Corrado, and J. Dean. Distributed representations of words and phrases and their compositionality. In NIPS’2013, pp. 3111–3119. 2013. ",
+        "bbox": [
+            169,
+            654,
+            823,
+            684
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Larsson Omberg, Jacqueline Salit, Neil Hackett, Jennifer Fuller, Rebecca Matthew, Lotfi Chouchane, Juan L Rodriguez-Flores, Carlos Bustamante, Ronald G Crystal, and Jason G Mezey. Inferring genome-wide patterns of admixture in qataris using fifty-five ancestral populations. BMC Genetics, 2012. doi: 10.1186/1471-2156-13-49. ",
+        "bbox": [
+            173,
+            691,
+            825,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Alkes L Price, Nick J Patterson, Robert M Plenge, Michael E Weinblatt, Nancy A Shadick, and D Reich. Principal components analysis corrects for stratification in genome-wide association studies. Nature Genetics, 2006. doi: 10.1038/ng1847. ",
+        "bbox": [
+            173,
+            756,
+            825,
+            799
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Jurgen Schmidhuber. Learning to control fast-weight memories: An alternative to dynamic recurrent ¨ networks. Neural Comput., 4(1):131–139, 1992. ",
+        "bbox": [
+            173,
+            806,
+            821,
+            837
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Sara Sheehan and Yun S Song. Deep learning for population genetic inference. PLoS Comput Biol, 2016. doi: 10.1371/journal.pcbi.1004845. ",
+        "bbox": [
+            173,
+            844,
+            823,
+            873
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Ritambhara Singh, Jack Lanchantin, Gabriel Robins, and Yanjun Qi. Deepchrome: deep-learning for predicting gene expression from histone modifications. Bioinformatics, 2016. doi: 10.1093/ bioinformatics/btw427. ",
+        "bbox": [
+            174,
+            882,
+            825,
+            922
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kenneth O. Stanley, David B. D’Ambrosio, and Jason Gauci. A hypercube-based encoding for evolving large-scale neural networks. Artif. Life, 15(2):185–212, April 2009. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Theano Development Team. Theano: A Python framework for fast computation of mathematical expressions. arXiv e-prints, abs/1605.02688, May 2016. URL http://arxiv.org/abs/ 1605.02688. ",
+        "bbox": [
+            174,
+            145,
+            825,
+            188
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "T. Tieleman and G. Hinton. Lecture 6.5—RmsProp: Divide the gradient by a running average of its recent magnitude. COURSERA: Neural Networks for Machine Learning, 2012. ",
+        "bbox": [
+            171,
+            202,
+            823,
+            229
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pascal Vincent, Hugo Larochelle, Yoshua Bengio, and Pierre-Antoine Manzagol. Extracting and composing robust features with denoising autoencoders. In Andrew McCallum and Sam Roweis (eds.), Proceedings of the 25th Annual International Conference on Machine Learning (ICML 2008), pp. 1096–1103. Omnipress, 2008. ",
+        "bbox": [
+            173,
+            243,
+            825,
+            299
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jian Zhou and Olga Troyanskaya. Predicting effects of noncoding variants with deep learningbased sequence model. Nature Methods, 2015. doi: 10.1038/nmeth.3547. ",
+        "bbox": [
+            173,
+            314,
+            823,
+            342
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A THE 1000 GENOMES PROJECT LEGENDS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            373,
+            547,
+            390
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.1 POPULATION ETHNICITY LEGEND ",
+        "bbox": [
+            176,
+            406,
+            450,
+            420
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACB: African Caribbeans in Barbados   \nASW: Americans of African Ancestry in SW USA   \nBEB: Bengali from Bangladesh   \nCDX: Chinese Dai in Xishuangbanna   \nCEU: Utah Residents (CEPH) with Northern and Western Ancestry   \nCHB: Han Chinese in Bejing   \nCHS: Southern Han Chinese   \nCLM: Colombians from Medellin   \nESN: Esan in Nigeria   \nFIN: Finnish in Finland   \nGBR: British in England and Scotland   \nGIH: Gujarati Indian from Houston   \nGWD: Gambian in Western Divisions in the Gambia   \nIBS: Iberian Population in Spain   \nITU: Indian Telugu from the UK   \nJPT: Japanese in Tokyo   \nKHV: Kinh in Ho Chi Minh City   \nLWK: Luhya in Webuye   \nMSL: Mende in Sierra Leone   \nMXL: Mexican Ancestry from Los Angeles   \nPEL: Peruvians from Lima   \nPJL: Punjabi from Lahore   \nPUR: Puerto Ricans   \nSTU: Sri Lankan Tamil from the UK   \nTSI: Toscani in Italia   \nYRI: Yoruba in Ibadan ",
+        "bbox": [
+            173,
+            434,
+            619,
+            792
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "A.2 GEOGPRAHICAL REGION LEGEND ",
+        "bbox": [
+            176,
+            828,
+            450,
+            840
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "AFR: African   \nAMR: Ad Mixed American   \nEAS: East Asian   \nEUR: European   \nSAS: South Asian ",
+        "bbox": [
+            173,
+            854,
+            359,
+            922
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "B OBTAINING THE 1000 GENOMES DATA ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            102,
+            531,
+            118
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "SNP data for the 1000G dataset was downloaded from ftp://ftp.1000genomes.ebi.ac. uk:21/vol1/ftp/release/20130502/supporting/hd_genotype_chip/ ",
+        "bbox": [
+            173,
+            133,
+            820,
+            162
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "− ALL . wgs . n h g r i c o r i e l l a f f y 6 . 2 0 1 4 0 8 2 5 . g e n o t y p e s h a s p e d . v c f . g z ",
+        "bbox": [
+            171,
+            167,
+            802,
+            198
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "− a f f y s a m p l e s . 2 0 1 4 1 1 1 8 . p a n e l ",
+        "bbox": [
+            176,
+            196,
+            459,
+            213
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Representative commands: ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            227,
+            362,
+            241
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "With PLINK v1.90b2n 64-bit https://www.cog-genomics.org/plink2 ",
+        "bbox": [
+            174,
+            248,
+            714,
+            263
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "# c o n v e r t v c f t o p l i n k f o r m a t ( b e d ) , a n d o n l y k e e p i n g common m a r k e r s ( m i n o r a l l e l e f r e q u e n c y $>$ 0 . 0 5 i n c o m b i n e d s a m p l e )   \n$>$ p l i n k −−v c f \\$ p a t h / ALL . wgs . n h g r i c o r i e l l a f f y 6 . 2 0 1 4 0 8 2 5 . g e n o t y p e s h a s p e d . v c f . g z −−maf 0 . 0 5 −−o u t $\\$ 1$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t −−n o t −c h r X Y MT −−make−b e d   \n# p r o d u c e a p r u n e d s u b s e t o f m a r k e r s t h a t a r e i n a p p r o x i m a t e l i n k a g e e q u i l i b r i u m w i t h e a c h o t h e r   \n$>$ p l i n k −− b f i l e \\$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t −−i n d e p − p a i r w i s e 50 5 0 . 5 −−o u t $\\$ 5$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t   \n# e x c l u d e m a r k e r s t o g e t p r u n e d s u b s e t   \n$>$ p l i n k −− b f i l e \\$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t −−e x c l u d e $\\$ 9$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 a u t . p r u n e . o u t −−r e c o d e A −− o u t $\\$ 5$ p a t h / a f f y 6 b i a l l e l i c s n p s m a f 0 0 5 t h i n n e d a u t A ",
+        "bbox": [
+            171,
+            268,
+            815,
+            478
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "For information on how to download this pre-processed dataset directly, please email Adriana Romero or Pierre Luc Carrier. ",
+        "bbox": [
+            171,
+            492,
+            825,
+            520
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "C PCA COMPONENTS AND MISCLASSIFICATION ERROR ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            541,
+            647,
+            556
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "In this section, we analyze the influence of increasing the number of PCs used to perform classification. Figure 4 depicts the obtained results when considering 100, 200, 400, 800 and $1 0 0 0 \\mathrm { P C s }$ . As shown in the figure, the best validation error comes with PC200. Further increasing the number of PCs improves the training error but does not generalize well on the validation set. ",
+        "bbox": [
+            173,
+            571,
+            826,
+            628
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/3c15c086e405ed2263ab05bb546dd4339ac37174db86a7f53d642a5af2568ee2.jpg",
+        "image_caption": [
+            "Figure 4: PCA: Train and validation misclassification error for different numbers of PCs. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            364,
+            655,
+            619,
+            803
+        ],
+        "page_idx": 10
+    }
+]

parse/train/Skn9Shcxe/Skn9Shcxe.md

@@ -0,0 +1,341 @@
+# HIGHWAY AND RESIDUAL NETWORKS LEARN UNROLLED ITERATIVE ESTIMATION
+
+Klaus Greff The Swiss AI Lab IDSIA (USI-SUPSI)
+
+Rupesh K. Srivastava & Jürgen Schmidhuber   
+The Swiss AI Lab IDSIA (USI-SUPSI) & NNAISENSE, Lugano, Switzerland   
+{klaus,rupesh,juergen}@idsia.ch
+
+# ABSTRACT
+
+The past year saw the introduction of new architectures such as Highway networks (Srivastava et al., 2015a) and Residual networks (He et al., 2015) which, for the first time, enabled the training of feedforward networks with dozens to hundreds of layers using simple gradient descent. While depth of representation has been posited as a primary reason for their success, there are indications that these architectures defy a popular view of deep learning as a hierarchical computation of increasingly abstract features at each layer.
+
+In this report, we argue that this view is incomplete and does not adequately explain several recent findings. We propose an alternative viewpoint based on unrolled iterative estimation—a group of successive layers iteratively refine their estimates of the same features instead of computing an entirely new representation. We demonstrate that this viewpoint directly leads to the construction of Highway and Residual networks. Finally we provide preliminary experiments to discuss the similarities and differences between the two architectures.
+
+# 1 INTRODUCTION
+
+Deep learning can be thought of as learning many levels of representation of the input which form a hierarchy of concepts (Deng & Yu, 2014; Goodfellow et al., 2016; LeCun et al., 2015) (but note that this is not the only view: cf. Schmidhuber (2015)). With fixed computational budget, deeper architectures are believed to possess greater representational power and, consequently, higher performance than shallower models. Intuitively, each layer of a deep neural network computes a new level of representation. For convolutional networks, Zeiler & Fergus (2014) visualized the features computed by each layer, and demonstrated that they in fact become increasingly abstract with depth. We refer to this way of thinking about neural networks as the representation view, which probably dates back to Hubel & Wiesel (1962). The representation view links the layers in a network to the abstraction levels of their representations, and as such represents a pervasive assumption in many recent publications including He et al. (2015) who describe the success of their Residual networks like this: “Solely due to our extremely deep representations, we obtain a $2 8 \%$ relative improvement on the COCO object detection dataset.”
+
+![](images/c72bd1edfa4f620b0d47ab0e9d8ff30d77ec65bad1319f56b2b35cfd2577ead1.jpg)  
+Figure 1: Illustrating our usage of blocks and stages in Highway and Residual networks.
+
+Surprisingly, increasing the depth of a network beyond a certain point often leads to a decline in performance even on the training set (Srivastava et al., 2015a). Since adding more layers cannot decrease representational power, this phenomenon is usually attributed to the vanishing gradient problem (Hochreiter, 1991). Therefore, even though deeper models are more powerful in principle, they often fall short in practice.
+
+Recently, training feedforward networks with hundreds of layers has become feasible through the invention of Highway networks Srivastava et al. (2015a) and Residual networks (ResNets; He et al. 2015). The latter have been widely successful in computer vision, advancing the state of the art on many benchmarks and winning several pattern recognition competitions (He et al., 2015), while Highway networks have been used to improve language modeling (Kim et al., 2015; Jozefowicz et al., 2016; Zilly et al., 2016) and translation (Lee et al., 2016). Both architectures have been introduced with the explicit goal of training deeper models.
+
+There are, however, some surprising findings that seem to contradict the applicability of the representation view to these very deep networks. For example, it has been reported that removing almost any layer from a trained Highway or Residual network has only minimal effect on its overall performance (Srivastava et al., 2015b; Veit et al., 2016). This idea has been extended to a layerwise dropout as a regularizer for ResNets (Huang et al., 2016b). But if each layer supposedly builds a new level of representation from the previous one, then removing any layer should critically disrupt the input for the following layer. So how is it possible that doing so seems to have only a negligible effect on the network output? Veit et al. (2016) even demonstrated that shuffling some of the layers in a trained ResNet barely affects performance.
+
+It has been argued that ResNets are better understood as ensembles of shallow networks (Huang et al., 2016b; Veit et al., 2016; Abdi & Nahavandi, 2016). According to this interpretation, ResNets implicitly average exponentially many subnetworks, each of which only use a subset of the layers. But the question remains open as to how a layer in such a subnetwork can successfully operate with changing input representations. This, along with other findings, begs the question as to whether the representation view is appropriate for understanding these new architectures.
+
+In this paper, we propose a new interpretation that reconciles the representation view with the operation of Highway and Residual networks: functional blocks1 in these networks do not compute entirely new representations; instead, they engage in an unrolled iterative estimation of representations that refine/improve upon their input representation, thus preserving feature identity. The transition to a new level of representation occurs when a dimensionality change—through projection—separates two groups of blocks which we refer to as a stage (Figure 1). Taking this perspective, we are able to explain previously elusive findings such as the effects of lesioning and shuffling. Furthermore, we formalize this notion and use it to directly derive Residual and Highway networks. Finally, we present some preliminary experiments to compare these two architectures and investigate some of their relative advantages and disadvantages.
+
+# 2 CHALLENGING THE REPRESENTATION VIEW
+
+This section provides a brief survey of some the findings and points of contention that seem to contradict a representation view of Highway and Residual networks.
+
+Staying Close to the Inputs. The success of ResNets has been partly attributed to the fact that they obviate the need to learn the identity mapping, which is difficult. However, learning the negative identity (so that a feature can replaced by a higher level one) should be at least as difficult. The fact that the residual form is useful indicates that Residual blocks typically stay close to the input representation, rather than replacing it.
+
+The analysis by Srivastava et al. (2015a) shows that in trained Highway networks, the activity of the transform gates is often sparse for each individual sample, while their average activity over all training samples is non-sparse. Most units learn to copy their inputs and only replace features selectively. Again, this means that most of the features are propagated unchanged rather than being combined and changed between layers—an observation that contradicts the idea of building a new level of abstraction at each layer.
+
+![](images/248158b1743dda819549c3d98d7aba61f66c22d696af5bc96bc30c387844b3c9.jpg)  
+Figure 2: (a) A single neural network layer that directly computes the desired representation. (b) The unrolled iterative estimation stage (e.g. from a Residual network) stretches the computation over three layers by first providing a noisy estimate of that representation, but then iteratively refines it over the next to layers. (c) A classic group of three layers can also distribute the computation, but they would produce a new representation at each layer. The iterative estimation stage in (b) can be seen as a middle ground between a single classic neural network layer, (a), and multiple classic layers, (c).
+
+Lesioning. If it were true that each layer computes a completely new set of features, then removing a layer from a trained network would completely change the input distribution for the next layer. We would then expect to see the overall performance drop to almost chance level. This is in fact what Veit et al. (2016) find for the 15-layer VGG network on CIFAR-10: removing any layer from the trained network sets the classification error to around $90 \%$ . But the lesioning studies conducted on Highway networks (Srivastava et al., 2015a) and ResNets (Veit et al., 2016) paint an entirely different picture: only a minor drop in performance is observed for any removed layer. This drop is more pronounced for the early layers and the layers that change dimensionality (i.e. number of filter maps and map sizes), but performance is always still far superior to random guessing.
+
+Huang et al. (2016b) take lesioning one step further and drop out entire ResNet layers as a regularizer during training. They describe their method as “[...] a training procedure that enables the seemingly contradictory setup to train short networks and use deep networks at test time”. The regularization effect of this procedure is explained as inducing an implicit ensemble of many shallow networks akin to normal dropout. Note that this explanation requires a departure from the representation view in that each layer has to cope with the possibility of having its entire input layer removed. Otherwise, most shallow networks in the ensemble would perform no better than chance level, just like the lesioned VGG net.
+
+Reshuffling. The link between layers and representation levels may be most clearly challenged by an experiment in Veit et al. (2016) where the layers of a trained 110-layer ResNet are reshuffled. Remarkably, error increases smoothly with the amount of reshuffling, and many re-orderings result only in a small increase in error. Note, however, that only layers within a stage are reshuffled, since the dimensionality of the swapped layers must match. Veit et al. (2016) take these results as evidence that ResNets behave as ensembles of exponentially many shallow networks.
+
+# 3 UNROLLED ITERATIVE ESTIMATION VIEW
+
+The representation view has guided neural networks research by providing intuitions about the “meaning” of their computations. In this section we will augment the representation view to deal with the incongruities and hopefully enable future research on these very deep architectures to reap the same benefits. The target of our modification is the mapping of layers/blocks of the network to levels of abstraction.
+
+At this point it is interesting to note that the one-to-one mapping of neural network layers to levels of abstraction is an implicit assumption rather than a stated part of the representation view. A recent deep learning textbook (Goodfellow et al., 2016) explicitly states: “[. . . ] the depth flowchart of the computations needed to compute the representation of each concept may be much deeper than the graph of the concepts themselves.” So in a strict sense the evidence from Section 2 does not in fact contradict a representation view of Residual and Highway networks. It only conflicts with the idea that each layer forms a new level of representation. We can therefore reconcile very deep networks with the representation view by explicitly giving up this assumption.
+
+Unrolled Iterative Estimation. We propose to think of blocks in Highway and Residual networks as performing unrolled iterative estimation of representations. By that we mean that the blocks in a stage work together to estimate and iteratively refine a single level of representation. The first layer in that stage already provides a (rough) estimate for the final representation. Subsequent layer in the stage then refine that estimate without changing the level of representation. So if the first layer in a stage detects simple shapes, then the rest of the layers in that stage will work at that level too.
+
+A good initial estimate for a representation should on average be correct even though it might have high variance. We can thus formalize the notion of "preserving feature identity" as being an unbiased estimator for the target representation. This means the units $\mathbf { \bar { \boldsymbol { a } } } _ { i } ^ { k }$ in different layers $k \in \{ 1 \ldots L \}$ are all estimators for the same latent feature $A _ { i }$ , where $A _ { i }$ refers to the (unknown) value towards which the $i$ -th feature is converging. The unbiased estimator condition can then be written as the expected difference between the estimator and the final feature:
+
+$$
+\underset { \mathbf { x } \in \mathbf { X } } { \mathbb { E } } [ a _ { i } ^ { k } - A _ { i } ] = 0 .
+$$
+
+Note that both the $a _ { i } ^ { k } \mathrm { s }$ and $A _ { i }$ depend on the samples $\mathbf { x }$ of the data-generating distribution $\boldsymbol { X }$ and are thus random variables. The fact that they both depend on the same $\mathbf { x }$ is also the reason we need to keep them within the same expectation and cannot just write $\mathbb { E } [ a _ { i } ^ { k } ] = A _ { i }$ .
+
+Feature Identity. A stage that performs iterative estimation is different from one that computes a new level of representation at each block because it preserves the feature identity. They operate differently even if their structure and their final representations are equivalent, because of the way they treat intermediate representations. This is illustrated in Figure 2, where the iterative estimation stage, (b), is contrasted with a single classic block (a), and multiple classic blocks, (c). In the iterative estimation case (middle), all the blocks within the stage produce estimates of the same representation (indicated by having different shades of blue). Whereas, in a classical stage, (c), the intermediate representations would all be different (represented by different colors).
+
+# 3.1 HIGHWAY AND RESIDUAL NETWORKS
+
+Both Highway and Residual networks address the problem of training very deep architectures by improving the error flow via identity skip connections that allow units to copy their inputs on to the next layer unchanged. This design principle was originally introduced in Long Short-Term Memory (LSTM) recurrent networks (Hochreiter & Schmidhuber, 1997) and mathematically these architectures correspond to a simplified LSTM network, "unrolled" over time.
+
+In Highway Networks, for each unit there are two additional gating units, which control how much (typically non-linear) transformation is applied (transform gate $T$ ) and how much to just copy of the activation from the corresponding unit in the previous layer (carry gate $C$ ). Let $H ( \mathbf { x } )$ be a nonlinear parametric function of the inputs, $\mathbf { x }$ , (typically an affine projection followed by pointwise non-linearity). Then a traditional feed-forward network layer can be written as:
+
+$$
+y ( \mathbf { x } ) = H ( \mathbf { x } ) .
+$$
+
+By adding two additional units, $T ( \mathbf { x } )$ and $C ( \mathbf { x } )$ a Highway layer can be written as:
+
+$$
+y ( \mathbf { x } ) = H ( \mathbf { x } ) \cdot T ( \mathbf { x } ) + \mathbf { x } \cdot C ( \mathbf { x } ) .
+$$
+
+Usually this is further simplified by coupling the gates, i.e. setting $C ( \mathbf { x } ) = 1 - T ( \mathbf { x } )$ :
+
+$$
+y ( \mathbf { x } ) = H ( \mathbf { x } ) \cdot T ( \mathbf { x } ) + \mathbf { x } \cdot ( 1 - T ( \mathbf { x } ) ) .
+$$
+
+ResNets simplify the Highway networks approach by reformulating the desired transformation as the input plus a residual $F ( \mathbf { x } )$ . The rationale behind this is that it is easier to optimize the residual form than the original function. For the extreme case where the desired function is the identity, this amounts to the trivial task of pushing the residual to zero:
+
+$$
+y ( \mathbf { x } ) = F ( \mathbf { x } ) + \mathbf { x } .
+$$
+
+As with Highway networks, Residual networks can be viewed as unfolded recurrent neural networks of the particular mathematical form (one with an identity self-connection) of an LSTM cell. This has been explicitly pointed out by Liao & Poggio (2016), who also argue that this could allow Residual networks to emulate recurrent processing in the visual cortex and thus adds to their biological plausibility. Setting $F ( \mathbf { x } ) = T ( \mathbf { x } ) [ H ( \mathbf { x } ) - \mathbf { x } ]$ converts Equation 5 to Equation 4 showing that both formulations differ only in the precise functional form for $F$ . Alternatively, Residual networks can be seen as a particular case of Highway networks where $C ( \mathbf { x } ) = T ( \mathbf { x } ) = \mathbf { 1 }$ and are not learned.
+
+# 3.2 DERIVING RESIDUAL NETWORKS
+
+Equation 1 can be used to directly derive the ResNet equation (Equation 5). First, it follows that the expected difference between outputs of two consecutive blocks in a stage is zero:
+
+$$
+\begin{array} { r } { \mathbb { E } [ a _ { i } ^ { k } - A _ { i } ] - \mathbb { E } [ a _ { i } ^ { k - 1 } - A _ { i } ] = 0 } \\ { \mathbb { E } [ a _ { i } ^ { k } - a _ { i } ^ { k - 1 } ] = 0 . } \end{array}
+$$
+
+If we write feature $a _ { i } ^ { k }$ as a combination of $a _ { i } ^ { k - 1 }$ and a residual $F _ { i }$ , it follows from Equation 7 that the residual has to be zero-mean:
+
+$$
+\begin{array} { c } { { a _ { i } ^ { k } = a _ { i } ^ { k - 1 } + F _ { i } } } \\ { { \implies \mathbb { E } [ F _ { i } ] = 0 . } } \end{array}
+$$
+
+Therefore, if the residual block $F$ has a zero mean over the training set, then Equation 1 holds and it can be said to maintain feature identity. Note that this is a reasonable assumption, especially when using batch normalization.
+
+# 3.3 DERIVING HIGHWAY NETWORKS
+
+The coupled Highway formula (Equation 4) can be directly derived as an alternative way of ensuring Equation 1 if we assume a $H _ { i }$ to be a new estimate of $A _ { i }$ . Highway layers then result from the optimal way to linearly combine the former estimate $a _ { i } ^ { k - 1 }$ with $H _ { i }$ such that the resulting $a _ { i } ^ { k }$ is a minimum variance estimate of $A _ { i }$ , i.e. requiring $\mathbb { E } [ a _ { i } ^ { k } - A _ { i } ] = 0$ and that $\mathrm { V a r } [ a _ { i } ^ { k } - A _ { i } ]$ is minimal.
+
+Let $\alpha _ { 1 } = \mathrm { V a r } [ a _ { i } ^ { k } - A _ { i } ] - \mathrm { C o v } [ a _ { i } ^ { k } - A _ { i } , a _ { i } ^ { k } - H _ { i } ]$ and $\alpha _ { 2 } = \mathrm { V a r } [ H _ { i } - A _ { i } ] - \mathrm { C o v } [ a _ { i } ^ { k } - A _ { i } , a _ { i } ^ { k } - H _ { i } ]$ , then the optimal linear way of combining them is then given by the following estimator (see Section A.1 for derivation):
+
+$$
+a _ { i } ^ { k + 1 } = \frac { \alpha _ { 2 } } { \alpha _ { 1 } + \alpha _ { 2 } } a _ { i } ^ { k } + \frac { \alpha _ { 1 } } { \alpha _ { 1 } + \alpha _ { 2 } } H _ { i } .
+$$
+
+If we use a neural network to compute $H _ { i }$ and another one to compute $\begin{array} { r } { T _ { i } = \frac { \alpha _ { 1 } } { \alpha _ { 1 } + \alpha _ { 2 } } } \end{array}$ , then we recover the Highway formula:
+
+$$
+a _ { i } ^ { k } = H _ { i } \cdot T _ { i } + a _ { i } ^ { k - 1 } \cdot ( 1 - T _ { i } ) ,
+$$
+
+where $H _ { i }$ and $T _ { i }$ are both functions of the previous layer activations $\pmb { a } ^ { k - 1 }$ .
+
+# 4 DISCUSSION
+
+# 4.1 IMPLICATIONS FOR HIGHWAY NETWORKS
+
+In Highway networks with coupled gates the mixing coefficients always sum to one. This ensures that the expectation of the new estimate will always be correct (cf. Equation 14). The precise value of mixing will only determine the variance of the new estimate. We can bound this variance to be less or equal to the variance of the previous layer by restricting both mixing coefficients to be positive. In Highway networks this is done by using the logistic sigmoid activation function for the transform gate $T _ { i }$ . This restriction is equivalent to the assumption of $\alpha _ { 1 }$ and $\alpha _ { 2 }$ having the same sign. This assumption holds, for example, if the error of the new estimate $H _ { i } - A _ { i }$ is independent of the old $a _ { i } ^ { k - 1 } - A _ { i }$ . Because in that case their covariance is zero and thus both alphas are positive.
+
+Using the logistic sigmoid as activation function for the transform gate further means that the preactivation of $T _ { i }$ implicitly estimates $\log \left( { \frac { \alpha _ { 2 } } { \alpha _ { 1 } } } \right)$ . This is easy to see because the logistic sigmoid of that
+
+![](images/09b7434de4705a1639d5c3d95d17608800a3f37dc81b0d8ddeef20cf504d2412.jpg)  
+Figure 3: Experimental corroboration of Equation 1. The average estimation error – an empirical estimate of the LHS in Equation $1 -$ for each block of each stage ( $\mathbf { \bar { X } }$ -axis). It stays close to zero in all stages of a 50-layer ResNet trained on the ILSVRC-2015 dataset. The standard deviation of the estimation error decreases as depth increases in each stage (left to right), indicating iterative refinement of the representations.
+
+term is
+
+$$
+\frac { 1 } { 1 + e ^ { \log ( \frac { \alpha _ { 2 } } { \alpha _ { 1 } } ) } } = \frac { 1 } { 1 + \frac { \alpha _ { 2 } } { \alpha _ { 1 } } } = \frac { \alpha _ { 1 } } { \alpha _ { 1 } + \alpha _ { 2 } } .
+$$
+
+For the simple case of independent estimates $( \mathrm { C o v } [ a _ { i } ^ { k } - A _ { i } , a _ { i } ^ { k } - H _ { i } ] = 0 )$ ), this gives us another way of understanding the transform gate bias: It controls our initial belief in the variance of the layers estimate as compared to the previous one. A low bias means that the layers on average produce a high variance estimate, and should thus only contribute little, which seems a reasonable assumption for initialization.
+
+# 4.2 EXPERIMENTAL CORROBORATION OF ITERATIVE ESTIMATION VIEW
+
+The primary prediction of the iterative estimation view is that the estimation error for Highway or Residual blocks within the same stage should be zero in expectation. To empirically test this claim, we extract the intermediate layer outputs for 5000 validation set images using the 50-layer ResNet trained on the ILSVRC-2015 dataset from He et al. (2015). These are then used to compute the empirical mean and standard deviation of the estimation error over the validation subset, for all blocks in the four Residual stages in the network. Finally the mean of the empirical mean and standard deviation is computed over the three spatial dimensions.
+
+Figure 3 shows that for the first three stages, the mean estimation error is indeed close to zero. This indicates that it is valid to interpret the role of Residual blocks in this network as that of iteratively refining a representation. Moreover, in each stage the standard deviation of the estimation error decreases over successive blocks, indicating the convergence of the refinement procedure. We note that stage four (with three blocks) appears to be underestimating the representation values, indicating a probable weak link in the architecture.
+
+# 4.3 VISUAL EVIDENCE & STAGE-WISE ESTIMATION OF FEATURES
+
+ResNets (He et al., 2015) and many other derived architectures share some common characteristics: They are divided into stages of Residual blocks that share the same dimensionality. In between these stages the input dimensionality changes, typically by down-sampling and an increase in the number of channels. These stages typically also increase in length: the early stages consist of fewer layers compared to later ones.
+
+We can now interpret these design choices from an iterative estimation point of view. From this perspective the level of representation stays the same within each stage, through the use of identity shortcut connections. Between stages, the level of representation is changed by the use of a projection to change dimensionality. This means that we expect the type of features that are detected to be very similar within a stage and jump in abstraction between stages. This view also suggests that the first few stages can be shorter, since low level representations tend to be relatively simple and need little iterative refinement. The features of later stages on the other hand are likely complex with numerous inter-dependencies and therefore benefit more from iterative refinement.
+
+![](images/3af1c9d6b4491436b6e6b02980dc723d1e9ab8d5fb1fe79d601e16612c6ecbac.jpg)  
+Figure 4: Feature visualization from Chu et al. (2017), reproduced with kind permission of the authors. It shows how the response of a single filter (unit) evolves over the three blocks (shown from left to right) of stage 1 in a 50-layer ResNet trained on ImageNet. On the left of each visualization are the top 9 patches from the ImageNet validation set that maximally activated that filter. To the right the corresponding guided backpropagation (Springenberg et al., 2014) visualizations are shown.
+
+Many visualization studies (such as those by Zeiler & Fergus (2014)) have examined the activities in trained convolutional networks and found evidence supporting the representation view. However, these studies were conducted on networks not designed for iterative estimation. The interpretation above paints a different picture for networks which learn unrolled iterative estimation. In these networks, we should observe stages and not layers corresponding to levels of representation.
+
+Indeed, visualization of Residual network features supports the iterative estimation view. In Figure 4 we reproduce visualizations from a study by Chu et al. (2017) who observe: “[. . . ] residual layers of the same dimensionality learn features that get refined and sharpened”. These visualizations show how the response of a single filter changes over three Residual blocks within the same stage of a 50-layer Residual network trained for image classification. Note that the filter appears to refine its response by including surrounding context, rather than changing it across blocks in the same stage. In the first block, the top nine activating patches for the filter include three light sources and six specular highlights. In later blocks, through the incorporation of spatial context, eight out of nine maximally activating patches are specular highlights. Similar refinement behavior is observed throughout the different stages of the network.
+
+Another finding in line with this implication of the iterative estimation view is that in some cases sharing weights of the Residual blocks within a stage doesn’t deteriorate performance much (Liao & Poggio, 2016). Similarly Lu & Renals (2015) shared the weights of the transform and carry gates of a thin and deep highway network, while still achieving better performance than both normal deep neural networks and Residual networks.
+
+# 4.4 REVISITING EVIDENCE AGAINST THE REPRESENTATION VIEW
+
+Staying Close to the Inputs. When iteratively re-estimating a variable, staying close to the old value should be a more common operation than changing it significantly. This is the reason why the ResNet formulation makes sense: learning the identity is hard and it is needed frequently. It also explains sparse transform gate activity in trained Highway networks: These networks learn to dynamically and selectively update individual features, while keeping most of the representation intact.
+
+Lesioning. Another implication of the iteration view is that processing in layers is incremental and somewhat interchangeable. Each layer (apart from the first) refines an already reasonable estimate of the representation. It follows that removing layers, like in the lesioning experiments, should have only a mild effect on the final result because doing so does not change the overall representation the next layer receives, only its quality. The following layer can still perform mostly the same operation, even with a somewhat noisy input. Layer dropout (Huang et al., 2016b) amplifies this effect by explicitly training the network to work with a variable number of iterations. By dropping random layers it further penalizes iterations relying on each other, which could be another explanation for the regularization effect of the technique.
+
+Shuffling. The layers within a stage should also be interchangeable to a certain degree, because they all work with the same input and output representations. Of course, this interchangeability is not without limitations. The network could learn to depend on a specific order of refinements, which would be disturbed by shuffling and lesioning. But we can expect these effects to be moderate in many cases, which is indeed what has been reported in the literature.
+
+Table 1: Comparison of several Highway network and Residual network variants.   
+
+<table><tr><td>Variant</td><td>Functional Form</td><td>Perplexity</td></tr><tr><td>Plain</td><td>H(x)</td><td>92.60</td></tr><tr><td>Residual</td><td>H(x)+x</td><td>91.32</td></tr><tr><td>T-Only</td><td>H(x):T(x) + x</td><td>82.94</td></tr><tr><td>C-Only</td><td>H(x)+x.C(x)</td><td>79.15</td></tr><tr><td>Coupled</td><td>H(x):T(x)+x·(1-T(x))</td><td>79.13</td></tr><tr><td>Full</td><td>H(x)·T(x)+x:C(x)</td><td>79.09</td></tr></table>
+
+(a) Comparing of various variants of the Highway formulation for character-aware neural language models (Kim et al., 2015).
+
+<table><tr><td>Variant</td><td>Top5 Error</td></tr><tr><td>Highway</td><td>10.03 ± 0.17</td></tr><tr><td>Highway-Full</td><td>10.21 ± 0.03</td></tr><tr><td>Resnet</td><td>9.40 ± 0.18</td></tr><tr><td>Highway + BN</td><td>7.53 ± 0.05</td></tr><tr><td>Highway-Full + BN</td><td>7.29 ± 0.11</td></tr><tr><td>Resnet+BN</td><td>7.17 ± 0.14</td></tr></table>
+
+(b) Comparing ILSVRC-2012 top5 classification error. Mean and std over 3 runs.
+
+# 5 COMPARATIVE CASE STUDIES
+
+The preceding sections show that we can construct both Highway and Residual architectures mathematically grounded in learning unrolled iterative estimation. The common feature between these architectures is that they preserve feature identities, and the primary difference is that they have different biases towards switching feature identities. Unfortunately, since our current understanding of the computations required to solve complex problems is limited, it is extremely hard to say a priori which architecture may be more suitable for which type of problems. Therefore, in this section we perform two case studies comparing and contrasting their behavior experimentally. The studies are each based on applications for which Residual and Highway layers respectively have been effective.
+
+# 5.1 IMAGE CLASSIFICATION
+
+Deep Residual networks outperformed all other entries at the 2016 ImageNet classification challenge. In this study we compare the performance of 50-layer convolutional Highway and Residual networks for ImageNet classification. Our aim is not to examine the importance of depth for this task— shallower networks have already outperformed deep Residual networks on all original Residual network benchmarks (Huang et al., 2016a; Szegedy et al., 2016). Instead, our goal is to fairly compare the two architectures, and test the following claims regarding deep convolutional Highway networks (He et al., 2015; 2016; Veit et al., 2016):
+
+1. They are harder to train, leading to stalled training or poor results.   
+2. They require extensive tuning of the initial bias, and even then produce much worse results compared to Residual networks.   
+3. They are wasteful in terms of parameters since they utilize extra learned gates, doubling the total parameters for the same number of units compared to a Residual layer.
+
+We train a 50-layer convolutional Highway network based on the 50-layer Residual network from He et al. (2015). The design of the two networks are identical (including use of batch normalization (BN) after every convolution operation), except that unlike Residual blocks, the Highway blocks use two sets of layers to learn $H$ and $T$ and then combine them using the coupled Highway formulation. We train two slight variations of the Highway network: Highway, in which $H$ has the same design as in a Residual block before addition i.e. Conv-BN-ReLU-Conv-BN-ReLU-Conv-BN, and Highway-Full, in which an additional third ReLU operation is added. The design of $T$ is Conv-BN-ReLU-Conv-BN-ReLU-Conv-BN-Sigmoid. As proposed initially for Highway layers, both $H$ and $T$ are learned using the same receptive fields and number of parameters. The transform gate biases are set to $- 1$ at the start of training. For fair comparison, the number of feature maps throughout the Highway network is reduced such that the total number of parameters is close to the Residual network. The training algorithm and learning rate schedule are kept the same as those used for the Residual network.
+
+The plots in Figure 5a show that the Residual network fits the data better—its final training loss is lower than the Highway network. The final performance of both networks on the validation set (see Table 1b) is very similar, with the Residual network producing a slightly better top-5 classification error of $7 . 1 7 \%$ vs. $7 . 5 3 \%$ for the Highway network. The Highway-Full network produces even closer results with a mean error of $7 . 2 9 \%$ . These results contradict claims 1 and 2 above, since the Highway networks are easy to train without requiring any bias tuning. However, there is some support for claim 3 since the Highway network appears to slightly underfit compared to the Residual network, suggesting lower capacity for the same number of parameters.
+
+Importance of Expressive Gating. The mismatch between the results above and claims 1 and 2 made by He et al. (2016) can be explained based on the importance of having sufficiently expressive transform gates. For experiments with Highway networks (which they refer to as Residual networks with exclusive gating), He et al. (2016) used $1 \times 1$ convolutions for the transform gate, instead of having the same receptive fields for the gates as the primary transformation $( H )$ , as done by Srivastava et al. (2015a). This change in design appears to be the primary cause of instabilities in learning since the gates can no longer function effectively. Therefore, it is important to use equally expressive transformations for $H$ and $T$ in Highway networks.
+
+Role of Batch Normalization. Since both architectures have built-in ease of optimization compared to plain networks, it is interesting to investigate the necessity of batch normalization for training these networks. Our derivation in Section 3.2 suggest that BN in Residual networks could take the role of an inductive bias towards iterative estimation by keeping the expected mean of the residual zero (cf. Equation 9). To investigate its role we train the networks above without any batch normalization. The resulting training curves are shown in Figure 5b of the supplementary.
+
+We find that without BN both networks reach an even lower training error than before while performing worse on the validation set indicating increased overfitting for both. This shows that BN is not necessary for training these networks and does not speed up learning. Interestingly, the effect is more pronounced for the Highway network, which now fits the data better than the ResNet. This contradicts claim 3, since a Highway network with the same number of parameters as a Residual network demonstrates slightly higher capacity. On the other hand both networks produce a higher validation error— $1 0 . 0 3 \%$ and $9 . 4 \bar { 0 } \%$ for the Highway and Residual network respectively—indicating a clear case of overfitting. This means that batch normalization provides regularization benefits that can’t easily be explained by either improved optimization nor by the inductive bias for Residual networks.
+
+# 5.2 LANGUAGE MODELING
+
+Next we compare different functional forms (or variants) of the Highway network formulation for the case of character-aware language modeling. Kim et al. (2015) have shown that utilizing a few Highway fully connected layers instead of conventional plain layers improves model performance for a variety of languages. The architecture consists of a stack of convolutional layers followed by Highway layers and then an LSTM layer which predicts the next word based on the history. Similar architectures have since been utilized for obtaining substantial improvements for large-scale language modeling (Jozefowicz et al., 2016) and character level machine translation (Lee et al., 2016). Highway layers with coupled gates have been used in all these studies.
+
+Only two to four Highway layers were necessary to obtain significant modeling improvements in the studies above. Thus, it is reasonable to assume that the central advantage of using Highway layers for this task is not easing of credit assignment over depth, but an improved modeling bias. To test how well Residual and other variants of Highway networks perform, we compare several language models trained on the Penn Treebank dataset using the same setup and code provided by Kim et al. (2015). We use the LSTM-Char-Large model, only changing the two Highway layers to different variants. The following variants are tested:
+
+Full The original Highway formulation based on the LSTM cell. We note that this variant uses more parameters than the others, since changing the layer size to reduce parameters would affect the rest of the network architecture as well.
+
+Coupled The most commonly used Highway variant, derived in Section 3.3.
+
+C-Only A Highway variant with a carry gate but no transform gate (always set to one).
+
+T-Only A Highway variant with a transform gate but no carry gate (always set to one).
+
+Residual The Residual form from He et al. (2015), in which both transform and carry gate are always one. For this variant we use four layers instead of two, to match the amount of computation/parameters of the other variants.
+
+The test set perplexity of each model is shown in Table 1a. We find that the the Full, Coupled and C-Only variants have similar performance, better than the T-Only variant and substantially better than the Residual variant. The Residual variant results in performance close to that obtained by using a single plain layer, even though four Residual layers are used. Learned gating of the identity connection is crucial for improving performance for this task.
+
+Recall that the Highway layers transform character-aware representations before feeding them into an LSTM layer. Thus the non-contextual word-level representations resulting from the convolutional layers are transformed into representations better suited for contextual language modeling. Since it is unlikely that the entire representation needs to change completely, this setting fits well with the iterative estimation perspective.
+
+Interestingly, Table 1a shows a significant advantage for all variants with a multiplicative gate on the inputs. These results suggest that in this setting it is crucial to dynamically replace parts of the input representation. Some features need to be changed drastically conditioned on other detected features such as word type while other features need to be retained. As a result, even though Residual networks are compatible with iterative estimation, they may not be the best choice for tasks where mixing adaptive feature transform/replacement and reuse is required.
+
+# 6 CONCLUSION
+
+This paper offers a new perspective on Highway and Residual networks as performing unrolled iterative estimation. As an extension of the popular representation view, it stands in contrast to the optimization perspective from which these architectures have originally been introduced. According to the new view, successive layers (within a stage) cooperate to compute a single level of representation. Therefore, the first layer already computes a rough estimate of that representation, which is then iteratively refined by the successive layers. Unlike layers in a conventional neural network, which each compute a new representation, these layers therefore preserve feature identity.
+
+We have further shown that both Residual and Highway networks can be directly derived from this new perspective. This offers a unified theory from which these architectures can be understood as two approaches to the same problem. This view further provides a framework from which to understand several surprising recent findings like resilience to lesioning, benefits of layer dropout, and the mild negative effects of layer reshuffling. Together with the derivations these results serve as compelling evidence for the validity of our new perspective.
+
+Motivated by their conceptual similarities we set out to compare Highway and Residual networks. In preliminary experiments we found that they give very similar results for networks of equal size, thus refuting some claims that Highway networks would need more parameters, or that any form of gating impairs the performance of Residual networks. In another example, we found non-gated identity skip-connections to perform significantly worse, and offered a possible explanation: If the task requires dynamically replacing individual features, then the use of gating is beneficial.
+
+The preliminary evidence presented in this report is meant as a starting point for further investigation. We hope that the unrolled iterative estimation perspective will provide valuable intuitions to help guide research into understanding, improving and possibly combining these exciting techniques.
+
+# ACKNOWLEDGEMENTS
+
+The authors wish to thank Faustino Gomez, Bas Steunebrink, Jonathan Masci, Sjoerd van Steenkiste and Christian Osendorfer for their feedback and support. We are grateful to NVIDIA Corporation for providing us a DGX-1 as part of the Pioneers of AI Research award. This research was supported by the EU project “INPUT” (H2020-ICT-2015 grant no. 687795).
+
+REFERENCES   
+Abdi, Masoud and Nahavandi, Saeid. Multi-Residual Networks. arXiv:1609.05672 [cs], September 2016.   
+Chu, Brian, Yang, Daylen, and Tadinada, Ravi. Visualizing Residual Networks. arXiv:1701.02362 [cs], January 2017.   
+Deng, Li and Yu, Dong. Deep Learning Methods and Applications. Foundations and Trends in Signal Processing, pp. 199–200, 2014.   
+Goodfellow, Ian, Bengio, Yoshua, and Courville, Aaron. Deep Learning. Book in preparation for MIT Press, 2016.   
+He, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Deep Residual Learning for Image Recognition. arXiv:1512.03385 [cs], December 2015.   
+He, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Identity Mappings in Deep Residual Networks. In Computer Vision–ECCV 2016, 2016.   
+Hochreiter, Sepp. Untersuchungen zu dynamischen neuronalen Netzen. Diploma, Technische Universität München, pp. 91, 1991.   
+Hochreiter, Sepp and Schmidhuber, Jürgen. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.   
+Huang, Gao, Liu, Zhuang, and Weinberger, Kilian Q. Densely Connected Convolutional Networks. arXiv:1608.06993 [cs], August 2016a.   
+Huang, Gao, Sun, Yu, Liu, Zhuang, Sedra, Daniel, and Weinberger, Kilian. Deep Networks with Stochastic Depth. arXiv:1603.09382 [cs], March 2016b.   
+Hubel, David H. and Wiesel, Torsten N. Receptive fields, binocular interaction and functional architecture in the cat’s visual cortex. The Journal of physiology, 160(1):106–154, 1962.   
+Jozefowicz, Rafal, Vinyals, Oriol, Schuster, Mike, Shazeer, Noam, and Wu, Yonghui. Exploring the limits of language modeling. arXiv preprint arXiv:1602.02410, 2016.   
+Kim, Yoon, Jernite, Yacine, Sontag, David, and Rush, Alexander M. Character-aware neural language models. arXiv preprint arXiv:1508.06615, 2015.   
+LeCun, Yann, Bengio, Yoshua, and Hinton, Geoffrey. Deep learning. Nature, 521(7553):436–444, May 2015. ISSN 0028-0836. doi: 10.1038/nature14539.   
+Lee, Jason, Cho, Kyunghyun, and Hofmann, Thomas. Fully Character-Level Neural Machine Translation without Explicit Segmentation. arXiv preprint arXiv:1610.03017, 2016.   
+Liao, Qianli and Poggio, Tomaso. Bridging the Gaps Between Residual Learning, Recurrent Neural Networks and Visual Cortex. arXiv:1604.03640 [cs], April 2016.   
+Lu, Liang and Renals, Steve. Small-footprint Deep Neural Networks with Highway Connections for Speech Recognition. arXiv:1512.04280 [cs], December 2015.   
+Schmidhuber, Jürgen. Deep learning in neural networks: An overview. Neural Networks, 61:85–117, January 2015. ISSN 0893-6080. doi: 10.1016/j.neunet.2014.09.003.   
+Springenberg, Jost Tobias, Dosovitskiy, Alexey, Brox, Thomas, and Riedmiller, Martin. Striving for Simplicity: The All Convolutional Net. arXiv:1412.6806 [cs], December 2014.   
+Srivastava, Rupesh K, Greff, Klaus, and Schmidhuber, Juergen. Training Very Deep Networks. In Cortes, C., Lawrence, N. D., Lee, D. D., Sugiyama, M., and Garnett, R. (eds.), Advances in Neural Information Processing Systems 28, pp. 2377–2385. Curran Associates, Inc., 2015a.   
+Srivastava, Rupesh Kumar, Greff, Klaus, and Schmidhuber, Jürgen. Highway Networks. arXiv:1505.00387 [cs], May 2015b.
+
+Szegedy, Christian, Ioffe, Sergey, Vanhoucke, Vincent, and Alemi, Alex. Inception-v4, InceptionResNet and the Impact of Residual Connections on Learning. arXiv:1602.07261 [cs], February 2016.
+
+Veit, Andreas, Wilber, Michael, and Belongie, Serge. Residual Networks are Exponential Ensembles of Relatively Shallow Networks. arXiv:1605.06431 [cs], May 2016.
+
+Zeiler, Matthew D. and Fergus, Rob. Visualizing and understanding convolutional networks. In European Conference on Computer Vision, pp. 818–833. Springer, 2014.
+
+Zilly, Julian Georg, Srivastava, Rupesh Kumar, Koutník, Jan, and Schmidhuber, Jürgen. Recurrent Highway Networks. arXiv:1607.03474 [cs], July 2016.
+
+![](images/f0a9278a7a7c56b67639b1d680b954144ef134bf734070b5cf2e8ec24142110b.jpg)  
+Figure 5: Comparing 50-layer Highway vs. Residual networks on ILSVRC-2012 classification.
+
+# A DERIVATION
+
+A.1 OPTIMAL LINEAR ESTIMATOR
+
+Assume two random variables $A$ and $B$ that are both noisy measurements of a third (latent) random variable $C$ :
+
+$$
+\mathbb { E } [ A - C ] = \mathbb { E } [ B - C ] = 0
+$$
+
+We call the corresponding variances $\mathrm { V a r } [ A - C ] = \sigma _ { A } ^ { 2 }$ and $\mathrm { V a r } [ B - C ] = \sigma _ { B } ^ { 2 }$ and covariance Cov[A, B] = σ2AB .
+
+We are looking for the linear estimator $q ( A , B ) = q _ { 0 } + q _ { 1 } A + q _ { 2 } B$ of $C$ with $\mathbb { E } [ q - C ] = 0$ (unbiased) that has minimum variance.
+
+$$
+\begin{array} { r } { \mathbb { E } [ q ( A , B ) - C ] = 0 } \\ { \mathbb { E } [ q _ { 0 } + q _ { 1 } A + q _ { 2 } B - C ] = 0 } \\ { \mathbb { E } [ q _ { 0 } + q _ { 1 } A - q _ { 1 } C + q _ { 2 } B - q _ { 2 } C + ( q _ { 1 } + q _ { 2 } - 1 ) C ] = 0 } \\ { \mathbb { E } [ q _ { 0 } + q _ { 1 } ( A - C ) + q _ { 2 } ( B - C ) + ( q _ { 1 } + q _ { 2 } - 1 ) C ] = 0 } \\ { q _ { 0 } + ( q _ { 1 } + q _ { 2 } - 1 ) \mathbb { E } [ C ] = 0 } \\ { \mathbb { E } [ C ] ( 1 - q _ { 1 } - q _ { 2 } ) = q _ { 0 } } \end{array}
+$$
+
+for all $\mathbb { E } [ C ]$ which is possible iff:
+
+$$
+q _ { 0 } = 0 \mathrm { a n d } q _ { 1 } + q _ { 2 } = 1 .
+$$
+
+The second condition about minimal variance thus reduces to:
+
+$$
+\begin{array} { r l } { \underset { q _ { 1 } , q _ { 2 } } { \operatorname { m i n i m i z e } } } & { { } \mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] } \\ { \mathrm { s u b j e c t } \mathrm { t o } } & { { } q _ { 1 } + q _ { 2 } = 1 } \end{array}
+$$
+
+We can solve this using Lagrangian multipliers. For that we need to take the derivative of the following term w.r.t. $q _ { 1 } , q _ { 2 }$ and $\lambda$ and set them to zero:
+
+$$
+\mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] - \lambda ( q _ { 1 } + q _ { 2 } - 1 ) )
+$$
+
+The first equation is therefore:
+
+$$
+\begin{array} { r l r } & { } & { \frac { d } { d q _ { 1 } } ( \mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] - \lambda ( q _ { 1 } + q _ { 2 } - 1 ) ) = 0 } \\ & { } & { \frac { d } { d q _ { 1 } } \mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] - \lambda = 0 } \\ & { } & { \frac { d } { d q _ { 1 } } \mathrm { V a r } [ q _ { 1 } ( A - C ) + q _ { 2 } ( B - C ) ] - \lambda = 0 } \\ & { } & { \frac { d } { d q _ { 1 } } ( q _ { 1 } ^ { 2 } \mathrm { V a r } [ A - C ] + 2 q _ { 1 } q _ { 2 } \mathrm { C o v } [ A - C , B - C ] ) - \lambda = 0 } \\ & { } & { 2 q _ { 1 } \sigma _ { A } ^ { 2 } + 2 q _ { 2 } \sigma _ { A B } ^ { 2 } - \lambda = 0 } \end{array}
+$$
+
+Analogously we get:
+
+and:
+
+$$
+\begin{array} { c } { { 2 q _ { 2 } \sigma _ { B } ^ { 2 } + 2 q _ { 1 } \sigma _ { A B } ^ { 2 } - \lambda = 0 } } \\ { { { } } } \\ { { q _ { 1 } + q _ { 2 } = 1 } } \end{array}
+$$
+
+Solving these equations gives us:
+
+$$
+\begin{array} { c } { { q _ { 1 } = \displaystyle \frac { \sigma _ { B } ^ { 2 } - \sigma _ { A B } ^ { 2 } } { \sigma _ { A } ^ { 2 } - 2 \sigma _ { A B } ^ { 2 } + \sigma _ { B } ^ { 2 } } } } \\ { { q _ { 2 } = \displaystyle \frac { \sigma _ { A } ^ { 2 } - \sigma _ { A B } ^ { 2 } } { \sigma _ { A } ^ { 2 } - 2 \sigma _ { A B } ^ { 2 } + \sigma _ { B } ^ { 2 } } } } \end{array}
+$$
+
+We can write our estimator in terms of $\alpha _ { 1 } = \sigma _ { B } ^ { 2 } - \sigma _ { A B } ^ { 2 }$ and $\alpha _ { 2 } = \sigma _ { A } ^ { 2 } - \sigma _ { A B } ^ { 2 }$ :
+
+$$
+q = \frac { \alpha _ { 1 } } { \alpha _ { 1 } + \alpha _ { 2 } } A + \frac { \alpha _ { 2 } } { \alpha _ { 1 } + \alpha _ { 2 } } B
+$$

parse/train/Skn9Shcxe/Skn9Shcxe_content_list.json

@@ -0,0 +1,1620 @@
+[
+    {
+        "type": "text",
+        "text": "HIGHWAY AND RESIDUAL NETWORKS LEARN UNROLLED ITERATIVE ESTIMATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            723,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Klaus Greff The Swiss AI Lab IDSIA (USI-SUPSI) ",
+        "bbox": [
+            184,
+            169,
+            444,
+            199
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Rupesh K. Srivastava & Jürgen Schmidhuber   \nThe Swiss AI Lab IDSIA (USI-SUPSI) & NNAISENSE, Lugano, Switzerland   \n{klaus,rupesh,juergen}@idsia.ch ",
+        "bbox": [
+            183,
+            219,
+            699,
+            262
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            297,
+            544,
+            313
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The past year saw the introduction of new architectures such as Highway networks (Srivastava et al., 2015a) and Residual networks (He et al., 2015) which, for the first time, enabled the training of feedforward networks with dozens to hundreds of layers using simple gradient descent. While depth of representation has been posited as a primary reason for their success, there are indications that these architectures defy a popular view of deep learning as a hierarchical computation of increasingly abstract features at each layer. ",
+        "bbox": [
+            233,
+            333,
+            766,
+            431
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this report, we argue that this view is incomplete and does not adequately explain several recent findings. We propose an alternative viewpoint based on unrolled iterative estimation—a group of successive layers iteratively refine their estimates of the same features instead of computing an entirely new representation. We demonstrate that this viewpoint directly leads to the construction of Highway and Residual networks. Finally we provide preliminary experiments to discuss the similarities and differences between the two architectures. ",
+        "bbox": [
+            233,
+            435,
+            764,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            569,
+            334,
+            585
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Deep learning can be thought of as learning many levels of representation of the input which form a hierarchy of concepts (Deng & Yu, 2014; Goodfellow et al., 2016; LeCun et al., 2015) (but note that this is not the only view: cf. Schmidhuber (2015)). With fixed computational budget, deeper architectures are believed to possess greater representational power and, consequently, higher performance than shallower models. Intuitively, each layer of a deep neural network computes a new level of representation. For convolutional networks, Zeiler & Fergus (2014) visualized the features computed by each layer, and demonstrated that they in fact become increasingly abstract with depth. We refer to this way of thinking about neural networks as the representation view, which probably dates back to Hubel & Wiesel (1962). The representation view links the layers in a network to the abstraction levels of their representations, and as such represents a pervasive assumption in many recent publications including He et al. (2015) who describe the success of their Residual networks like this: “Solely due to our extremely deep representations, we obtain a $2 8 \\%$ relative improvement on the COCO object detection dataset.” ",
+        "bbox": [
+            174,
+            604,
+            517,
+            896
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/c72bd1edfa4f620b0d47ab0e9d8ff30d77ec65bad1319f56b2b35cfd2577ead1.jpg",
+        "image_caption": [
+            "Figure 1: Illustrating our usage of blocks and stages in Highway and Residual networks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            540,
+            606,
+            813,
+            844
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            896,
+            823,
+            922
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Surprisingly, increasing the depth of a network beyond a certain point often leads to a decline in performance even on the training set (Srivastava et al., 2015a). Since adding more layers cannot decrease representational power, this phenomenon is usually attributed to the vanishing gradient problem (Hochreiter, 1991). Therefore, even though deeper models are more powerful in principle, they often fall short in practice. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            172
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, training feedforward networks with hundreds of layers has become feasible through the invention of Highway networks Srivastava et al. (2015a) and Residual networks (ResNets; He et al. 2015). The latter have been widely successful in computer vision, advancing the state of the art on many benchmarks and winning several pattern recognition competitions (He et al., 2015), while Highway networks have been used to improve language modeling (Kim et al., 2015; Jozefowicz et al., 2016; Zilly et al., 2016) and translation (Lee et al., 2016). Both architectures have been introduced with the explicit goal of training deeper models. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            279
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "There are, however, some surprising findings that seem to contradict the applicability of the representation view to these very deep networks. For example, it has been reported that removing almost any layer from a trained Highway or Residual network has only minimal effect on its overall performance (Srivastava et al., 2015b; Veit et al., 2016). This idea has been extended to a layerwise dropout as a regularizer for ResNets (Huang et al., 2016b). But if each layer supposedly builds a new level of representation from the previous one, then removing any layer should critically disrupt the input for the following layer. So how is it possible that doing so seems to have only a negligible effect on the network output? Veit et al. (2016) even demonstrated that shuffling some of the layers in a trained ResNet barely affects performance. ",
+        "bbox": [
+            174,
+            285,
+            825,
+            410
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "It has been argued that ResNets are better understood as ensembles of shallow networks (Huang et al., 2016b; Veit et al., 2016; Abdi & Nahavandi, 2016). According to this interpretation, ResNets implicitly average exponentially many subnetworks, each of which only use a subset of the layers. But the question remains open as to how a layer in such a subnetwork can successfully operate with changing input representations. This, along with other findings, begs the question as to whether the representation view is appropriate for understanding these new architectures. ",
+        "bbox": [
+            174,
+            416,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new interpretation that reconciles the representation view with the operation of Highway and Residual networks: functional blocks1 in these networks do not compute entirely new representations; instead, they engage in an unrolled iterative estimation of representations that refine/improve upon their input representation, thus preserving feature identity. The transition to a new level of representation occurs when a dimensionality change—through projection—separates two groups of blocks which we refer to as a stage (Figure 1). Taking this perspective, we are able to explain previously elusive findings such as the effects of lesioning and shuffling. Furthermore, we formalize this notion and use it to directly derive Residual and Highway networks. Finally, we present some preliminary experiments to compare these two architectures and investigate some of their relative advantages and disadvantages. ",
+        "bbox": [
+            174,
+            507,
+            825,
+            646
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 CHALLENGING THE REPRESENTATION VIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            667,
+            575,
+            683
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "This section provides a brief survey of some the findings and points of contention that seem to contradict a representation view of Highway and Residual networks. ",
+        "bbox": [
+            174,
+            698,
+            823,
+            727
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Staying Close to the Inputs. The success of ResNets has been partly attributed to the fact that they obviate the need to learn the identity mapping, which is difficult. However, learning the negative identity (so that a feature can replaced by a higher level one) should be at least as difficult. The fact that the residual form is useful indicates that Residual blocks typically stay close to the input representation, rather than replacing it. ",
+        "bbox": [
+            174,
+            742,
+            825,
+            811
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The analysis by Srivastava et al. (2015a) shows that in trained Highway networks, the activity of the transform gates is often sparse for each individual sample, while their average activity over all training samples is non-sparse. Most units learn to copy their inputs and only replace features selectively. Again, this means that most of the features are propagated unchanged rather than being combined and changed between layers—an observation that contradicts the idea of building a new level of abstraction at each layer. ",
+        "bbox": [
+            174,
+            819,
+            825,
+            875
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/248158b1743dda819549c3d98d7aba61f66c22d696af5bc96bc30c387844b3c9.jpg",
+        "image_caption": [
+            "Figure 2: (a) A single neural network layer that directly computes the desired representation. (b) The unrolled iterative estimation stage (e.g. from a Residual network) stretches the computation over three layers by first providing a noisy estimate of that representation, but then iteratively refines it over the next to layers. (c) A classic group of three layers can also distribute the computation, but they would produce a new representation at each layer. The iterative estimation stage in (b) can be seen as a middle ground between a single classic neural network layer, (a), and multiple classic layers, (c). "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            127,
+            496,
+            287
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            173,
+            315,
+            823,
+            343
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Lesioning. If it were true that each layer computes a completely new set of features, then removing a layer from a trained network would completely change the input distribution for the next layer. We would then expect to see the overall performance drop to almost chance level. This is in fact what Veit et al. (2016) find for the 15-layer VGG network on CIFAR-10: removing any layer from the trained network sets the classification error to around $90 \\%$ . But the lesioning studies conducted on Highway networks (Srivastava et al., 2015a) and ResNets (Veit et al., 2016) paint an entirely different picture: only a minor drop in performance is observed for any removed layer. This drop is more pronounced for the early layers and the layers that change dimensionality (i.e. number of filter maps and map sizes), but performance is always still far superior to random guessing. ",
+        "bbox": [
+            174,
+            361,
+            825,
+            487
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Huang et al. (2016b) take lesioning one step further and drop out entire ResNet layers as a regularizer during training. They describe their method as “[...] a training procedure that enables the seemingly contradictory setup to train short networks and use deep networks at test time”. The regularization effect of this procedure is explained as inducing an implicit ensemble of many shallow networks akin to normal dropout. Note that this explanation requires a departure from the representation view in that each layer has to cope with the possibility of having its entire input layer removed. Otherwise, most shallow networks in the ensemble would perform no better than chance level, just like the lesioned VGG net. ",
+        "bbox": [
+            174,
+            493,
+            825,
+            604
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Reshuffling. The link between layers and representation levels may be most clearly challenged by an experiment in Veit et al. (2016) where the layers of a trained 110-layer ResNet are reshuffled. Remarkably, error increases smoothly with the amount of reshuffling, and many re-orderings result only in a small increase in error. Note, however, that only layers within a stage are reshuffled, since the dimensionality of the swapped layers must match. Veit et al. (2016) take these results as evidence that ResNets behave as ensembles of exponentially many shallow networks. ",
+        "bbox": [
+            174,
+            622,
+            825,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 UNROLLED ITERATIVE ESTIMATION VIEW ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            558,
+            746
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The representation view has guided neural networks research by providing intuitions about the “meaning” of their computations. In this section we will augment the representation view to deal with the incongruities and hopefully enable future research on these very deep architectures to reap the same benefits. The target of our modification is the mapping of layers/blocks of the network to levels of abstraction. ",
+        "bbox": [
+            173,
+            763,
+            823,
+            833
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "At this point it is interesting to note that the one-to-one mapping of neural network layers to levels of abstraction is an implicit assumption rather than a stated part of the representation view. A recent deep learning textbook (Goodfellow et al., 2016) explicitly states: “[. . . ] the depth flowchart of the computations needed to compute the representation of each concept may be much deeper than the graph of the concepts themselves.” So in a strict sense the evidence from Section 2 does not in fact contradict a representation view of Residual and Highway networks. It only conflicts with the idea that each layer forms a new level of representation. We can therefore reconcile very deep networks with the representation view by explicitly giving up this assumption. ",
+        "bbox": [
+            174,
+            840,
+            825,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Unrolled Iterative Estimation. We propose to think of blocks in Highway and Residual networks as performing unrolled iterative estimation of representations. By that we mean that the blocks in a stage work together to estimate and iteratively refine a single level of representation. The first layer in that stage already provides a (rough) estimate for the final representation. Subsequent layer in the stage then refine that estimate without changing the level of representation. So if the first layer in a stage detects simple shapes, then the rest of the layers in that stage will work at that level too. ",
+        "bbox": [
+            174,
+            147,
+            825,
+            231
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "A good initial estimate for a representation should on average be correct even though it might have high variance. We can thus formalize the notion of \"preserving feature identity\" as being an unbiased estimator for the target representation. This means the units $\\mathbf { \\bar { \\boldsymbol { a } } } _ { i } ^ { k }$ in different layers $k \\in \\{ 1 \\ldots L \\}$ are all estimators for the same latent feature $A _ { i }$ , where $A _ { i }$ refers to the (unknown) value towards which the $i$ -th feature is converging. The unbiased estimator condition can then be written as the expected difference between the estimator and the final feature: ",
+        "bbox": [
+            173,
+            237,
+            825,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d0ad18db3128a6c19ab981ba5c171be0897f233f373000d28a2a8f23b1c6c8d9.jpg",
+        "text": "$$\n\\underset { \\mathbf { x } \\in \\mathbf { X } } { \\mathbb { E } } [ a _ { i } ^ { k } - A _ { i } ] = 0 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            434,
+            325,
+            563,
+            352
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Note that both the $a _ { i } ^ { k } \\mathrm { s }$ and $A _ { i }$ depend on the samples $\\mathbf { x }$ of the data-generating distribution $\\boldsymbol { X }$ and are thus random variables. The fact that they both depend on the same $\\mathbf { x }$ is also the reason we need to keep them within the same expectation and cannot just write $\\mathbb { E } [ a _ { i } ^ { k } ] = A _ { i }$ . ",
+        "bbox": [
+            174,
+            359,
+            825,
+            402
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Feature Identity. A stage that performs iterative estimation is different from one that computes a new level of representation at each block because it preserves the feature identity. They operate differently even if their structure and their final representations are equivalent, because of the way they treat intermediate representations. This is illustrated in Figure 2, where the iterative estimation stage, (b), is contrasted with a single classic block (a), and multiple classic blocks, (c). In the iterative estimation case (middle), all the blocks within the stage produce estimates of the same representation (indicated by having different shades of blue). Whereas, in a classical stage, (c), the intermediate representations would all be different (represented by different colors). ",
+        "bbox": [
+            173,
+            416,
+            825,
+            529
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.1 HIGHWAY AND RESIDUAL NETWORKS",
+        "text_level": 1,
+        "bbox": [
+            176,
+            546,
+            480,
+            560
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Both Highway and Residual networks address the problem of training very deep architectures by improving the error flow via identity skip connections that allow units to copy their inputs on to the next layer unchanged. This design principle was originally introduced in Long Short-Term Memory (LSTM) recurrent networks (Hochreiter & Schmidhuber, 1997) and mathematically these architectures correspond to a simplified LSTM network, \"unrolled\" over time. ",
+        "bbox": [
+            174,
+            571,
+            825,
+            642
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In Highway Networks, for each unit there are two additional gating units, which control how much (typically non-linear) transformation is applied (transform gate $T$ ) and how much to just copy of the activation from the corresponding unit in the previous layer (carry gate $C$ ). Let $H ( \\mathbf { x } )$ be a nonlinear parametric function of the inputs, $\\mathbf { x }$ , (typically an affine projection followed by pointwise non-linearity). Then a traditional feed-forward network layer can be written as: ",
+        "bbox": [
+            173,
+            648,
+            825,
+            718
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e171d3017f5492dad76c1bdd660ab028d91e8a9e54a0137f08553f7432daac5c.jpg",
+        "text": "$$\ny ( \\mathbf { x } ) = H ( \\mathbf { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            449,
+            724,
+            549,
+            742
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "By adding two additional units, $T ( \\mathbf { x } )$ and $C ( \\mathbf { x } )$ a Highway layer can be written as: ",
+        "bbox": [
+            173,
+            747,
+            715,
+            763
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ef8f6dbf275ef29d8048db17221e7ca1d1add87bc8b2224fa113a24676010b98.jpg",
+        "text": "$$\ny ( \\mathbf { x } ) = H ( \\mathbf { x } ) \\cdot T ( \\mathbf { x } ) + \\mathbf { x } \\cdot C ( \\mathbf { x } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            770,
+            609,
+            787
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Usually this is further simplified by coupling the gates, i.e. setting $C ( \\mathbf { x } ) = 1 - T ( \\mathbf { x } )$ : ",
+        "bbox": [
+            173,
+            792,
+            736,
+            809
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6dd460975ad552f47453c9afa0cf3e65ae141426c6db6ea0d1fc10cd2fd175db.jpg",
+        "text": "$$\ny ( \\mathbf { x } ) = H ( \\mathbf { x } ) \\cdot T ( \\mathbf { x } ) + \\mathbf { x } \\cdot ( 1 - T ( \\mathbf { x } ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            367,
+            814,
+            630,
+            832
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "ResNets simplify the Highway networks approach by reformulating the desired transformation as the input plus a residual $F ( \\mathbf { x } )$ . The rationale behind this is that it is easier to optimize the residual form than the original function. For the extreme case where the desired function is the identity, this amounts to the trivial task of pushing the residual to zero: ",
+        "bbox": [
+            174,
+            845,
+            823,
+            901
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/479373c6321cc3baa7b7b54d87ca9e8db77d96512f60d1c5f632a634af3cde27.jpg",
+        "text": "$$\ny ( \\mathbf { x } ) = F ( \\mathbf { x } ) + \\mathbf { x } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            436,
+            907,
+            562,
+            925
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "As with Highway networks, Residual networks can be viewed as unfolded recurrent neural networks of the particular mathematical form (one with an identity self-connection) of an LSTM cell. This has been explicitly pointed out by Liao & Poggio (2016), who also argue that this could allow Residual networks to emulate recurrent processing in the visual cortex and thus adds to their biological plausibility. Setting $F ( \\mathbf { x } ) = T ( \\mathbf { x } ) [ H ( \\mathbf { x } ) - \\mathbf { x } ]$ converts Equation 5 to Equation 4 showing that both formulations differ only in the precise functional form for $F$ . Alternatively, Residual networks can be seen as a particular case of Highway networks where $C ( \\mathbf { x } ) = T ( \\mathbf { x } ) = \\mathbf { 1 }$ and are not learned. ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.2 DERIVING RESIDUAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            218,
+            447,
+            232
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Equation 1 can be used to directly derive the ResNet equation (Equation 5). First, it follows that the expected difference between outputs of two consecutive blocks in a stage is zero: ",
+        "bbox": [
+            173,
+            243,
+            823,
+            272
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6e2163ae6da6e2a2eeb8ce02321b1b2163fd42a1d8efd68de3e412db395c74be.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } [ a _ { i } ^ { k } - A _ { i } ] - \\mathbb { E } [ a _ { i } ^ { k - 1 } - A _ { i } ] = 0 } \\\\ { \\mathbb { E } [ a _ { i } ^ { k } - a _ { i } ^ { k - 1 } ] = 0 . } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            387,
+            277,
+            611,
+            321
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If we write feature $a _ { i } ^ { k }$ as a combination of $a _ { i } ^ { k - 1 }$ and a residual $F _ { i }$ , it follows from Equation 7 that the residual has to be zero-mean: ",
+        "bbox": [
+            173,
+            325,
+            825,
+            354
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a4ae41a5e42b4b09e4dee5f0f0eb0b56989ca1a4bc45d2b71f09917aacda6fc6.jpg",
+        "text": "$$\n\\begin{array} { c } { { a _ { i } ^ { k } = a _ { i } ^ { k - 1 } + F _ { i } } } \\\\ { { \\implies \\mathbb { E } [ F _ { i } ] = 0 . } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            358,
+            584,
+            398
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Therefore, if the residual block $F$ has a zero mean over the training set, then Equation 1 holds and it can be said to maintain feature identity. Note that this is a reasonable assumption, especially when using batch normalization. ",
+        "bbox": [
+            173,
+            401,
+            825,
+            444
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.3 DERIVING HIGHWAY NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            460,
+            444,
+            476
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The coupled Highway formula (Equation 4) can be directly derived as an alternative way of ensuring Equation 1 if we assume a $H _ { i }$ to be a new estimate of $A _ { i }$ . Highway layers then result from the optimal way to linearly combine the former estimate $a _ { i } ^ { k - 1 }$ with $H _ { i }$ such that the resulting $a _ { i } ^ { k }$ is a minimum variance estimate of $A _ { i }$ , i.e. requiring $\\mathbb { E } [ a _ { i } ^ { k } - A _ { i } ] = 0$ and that $\\mathrm { V a r } [ a _ { i } ^ { k } - A _ { i } ]$ is minimal. ",
+        "bbox": [
+            173,
+            486,
+            825,
+            547
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Let $\\alpha _ { 1 } = \\mathrm { V a r } [ a _ { i } ^ { k } - A _ { i } ] - \\mathrm { C o v } [ a _ { i } ^ { k } - A _ { i } , a _ { i } ^ { k } - H _ { i } ]$ and $\\alpha _ { 2 } = \\mathrm { V a r } [ H _ { i } - A _ { i } ] - \\mathrm { C o v } [ a _ { i } ^ { k } - A _ { i } , a _ { i } ^ { k } - H _ { i } ]$ , then the optimal linear way of combining them is then given by the following estimator (see Section A.1 for derivation): ",
+        "bbox": [
+            174,
+            553,
+            825,
+            595
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e94fd4ef95f7bcf2459555b8dfdf54df2c103453eecc0fac061d2975c0485198.jpg",
+        "text": "$$\na _ { i } ^ { k + 1 } = \\frac { \\alpha _ { 2 } } { \\alpha _ { 1 } + \\alpha _ { 2 } } a _ { i } ^ { k } + \\frac { \\alpha _ { 1 } } { \\alpha _ { 1 } + \\alpha _ { 2 } } H _ { i } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            380,
+            594,
+            619,
+            623
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "If we use a neural network to compute $H _ { i }$ and another one to compute $\\begin{array} { r } { T _ { i } = \\frac { \\alpha _ { 1 } } { \\alpha _ { 1 } + \\alpha _ { 2 } } } \\end{array}$ , then we recover the Highway formula: ",
+        "bbox": [
+            173,
+            632,
+            823,
+            661
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/da542c1142b547fae25590bc1459c1aed238fc1f2a50d0a81b8fe7b621d478d2.jpg",
+        "text": "$$\na _ { i } ^ { k } = H _ { i } \\cdot T _ { i } + a _ { i } ^ { k - 1 } \\cdot ( 1 - T _ { i } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            392,
+            660,
+            604,
+            680
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { i }$ and $T _ { i }$ are both functions of the previous layer activations $\\pmb { a } ^ { k - 1 }$ . ",
+        "bbox": [
+            174,
+            684,
+            661,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            310,
+            734
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 IMPLICATIONS FOR HIGHWAY NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            750,
+            506,
+            763
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In Highway networks with coupled gates the mixing coefficients always sum to one. This ensures that the expectation of the new estimate will always be correct (cf. Equation 14). The precise value of mixing will only determine the variance of the new estimate. We can bound this variance to be less or equal to the variance of the previous layer by restricting both mixing coefficients to be positive. In Highway networks this is done by using the logistic sigmoid activation function for the transform gate $T _ { i }$ . This restriction is equivalent to the assumption of $\\alpha _ { 1 }$ and $\\alpha _ { 2 }$ having the same sign. This assumption holds, for example, if the error of the new estimate $H _ { i } - A _ { i }$ is independent of the old $a _ { i } ^ { k - 1 } - A _ { i }$ . Because in that case their covariance is zero and thus both alphas are positive. ",
+        "bbox": [
+            173,
+            775,
+            825,
+            888
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Using the logistic sigmoid as activation function for the transform gate further means that the preactivation of $T _ { i }$ implicitly estimates $\\log \\left( { \\frac { \\alpha _ { 2 } } { \\alpha _ { 1 } } } \\right)$ . This is easy to see because the logistic sigmoid of that ",
+        "bbox": [
+            173,
+            895,
+            823,
+            926
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/09b7434de4705a1639d5c3d95d17608800a3f37dc81b0d8ddeef20cf504d2412.jpg",
+        "image_caption": [
+            "Figure 3: Experimental corroboration of Equation 1. The average estimation error – an empirical estimate of the LHS in Equation $1 -$ for each block of each stage ( $\\mathbf { \\bar { X } }$ -axis). It stays close to zero in all stages of a 50-layer ResNet trained on the ILSVRC-2015 dataset. The standard deviation of the estimation error decreases as depth increases in each stage (left to right), indicating iterative refinement of the representations. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            214,
+            116,
+            764,
+            241
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "term is ",
+        "bbox": [
+            173,
+            363,
+            222,
+            376
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/c72144e5086e77ae5fce89ceed2fef5daa630e2e165ddd56e77bd38570e9c8e4.jpg",
+        "text": "$$\n\\frac { 1 } { 1 + e ^ { \\log ( \\frac { \\alpha _ { 2 } } { \\alpha _ { 1 } } ) } } = \\frac { 1 } { 1 + \\frac { \\alpha _ { 2 } } { \\alpha _ { 1 } } } = \\frac { \\alpha _ { 1 } } { \\alpha _ { 1 } + \\alpha _ { 2 } } .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            375,
+            372,
+            622,
+            409
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For the simple case of independent estimates $( \\mathrm { C o v } [ a _ { i } ^ { k } - A _ { i } , a _ { i } ^ { k } - H _ { i } ] = 0 )$ ), this gives us another way of understanding the transform gate bias: It controls our initial belief in the variance of the layers estimate as compared to the previous one. A low bias means that the layers on average produce a high variance estimate, and should thus only contribute little, which seems a reasonable assumption for initialization. ",
+        "bbox": [
+            174,
+            414,
+            825,
+            484
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 EXPERIMENTAL CORROBORATION OF ITERATIVE ESTIMATION VIEW ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            503,
+            689,
+            518
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The primary prediction of the iterative estimation view is that the estimation error for Highway or Residual blocks within the same stage should be zero in expectation. To empirically test this claim, we extract the intermediate layer outputs for 5000 validation set images using the 50-layer ResNet trained on the ILSVRC-2015 dataset from He et al. (2015). These are then used to compute the empirical mean and standard deviation of the estimation error over the validation subset, for all blocks in the four Residual stages in the network. Finally the mean of the empirical mean and standard deviation is computed over the three spatial dimensions. ",
+        "bbox": [
+            174,
+            529,
+            825,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Figure 3 shows that for the first three stages, the mean estimation error is indeed close to zero. This indicates that it is valid to interpret the role of Residual blocks in this network as that of iteratively refining a representation. Moreover, in each stage the standard deviation of the estimation error decreases over successive blocks, indicating the convergence of the refinement procedure. We note that stage four (with three blocks) appears to be underestimating the representation values, indicating a probable weak link in the architecture. ",
+        "bbox": [
+            174,
+            635,
+            825,
+            718
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.3 VISUAL EVIDENCE & STAGE-WISE ESTIMATION OF FEATURES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            736,
+            647,
+            751
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "ResNets (He et al., 2015) and many other derived architectures share some common characteristics: They are divided into stages of Residual blocks that share the same dimensionality. In between these stages the input dimensionality changes, typically by down-sampling and an increase in the number of channels. These stages typically also increase in length: the early stages consist of fewer layers compared to later ones. ",
+        "bbox": [
+            174,
+            762,
+            825,
+            833
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "We can now interpret these design choices from an iterative estimation point of view. From this perspective the level of representation stays the same within each stage, through the use of identity shortcut connections. Between stages, the level of representation is changed by the use of a projection to change dimensionality. This means that we expect the type of features that are detected to be very similar within a stage and jump in abstraction between stages. This view also suggests that the first few stages can be shorter, since low level representations tend to be relatively simple and need little iterative refinement. The features of later stages on the other hand are likely complex with numerous inter-dependencies and therefore benefit more from iterative refinement. ",
+        "bbox": [
+            174,
+            839,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/3af1c9d6b4491436b6e6b02980dc723d1e9ab8d5fb1fe79d601e16612c6ecbac.jpg",
+        "image_caption": [
+            "Figure 4: Feature visualization from Chu et al. (2017), reproduced with kind permission of the authors. It shows how the response of a single filter (unit) evolves over the three blocks (shown from left to right) of stage 1 in a 50-layer ResNet trained on ImageNet. On the left of each visualization are the top 9 patches from the ImageNet validation set that maximally activated that filter. To the right the corresponding guided backpropagation (Springenberg et al., 2014) visualizations are shown. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            821,
+            176
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            284,
+            820,
+            311
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Many visualization studies (such as those by Zeiler & Fergus (2014)) have examined the activities in trained convolutional networks and found evidence supporting the representation view. However, these studies were conducted on networks not designed for iterative estimation. The interpretation above paints a different picture for networks which learn unrolled iterative estimation. In these networks, we should observe stages and not layers corresponding to levels of representation. ",
+        "bbox": [
+            174,
+            319,
+            825,
+            388
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Indeed, visualization of Residual network features supports the iterative estimation view. In Figure 4 we reproduce visualizations from a study by Chu et al. (2017) who observe: “[. . . ] residual layers of the same dimensionality learn features that get refined and sharpened”. These visualizations show how the response of a single filter changes over three Residual blocks within the same stage of a 50-layer Residual network trained for image classification. Note that the filter appears to refine its response by including surrounding context, rather than changing it across blocks in the same stage. In the first block, the top nine activating patches for the filter include three light sources and six specular highlights. In later blocks, through the incorporation of spatial context, eight out of nine maximally activating patches are specular highlights. Similar refinement behavior is observed throughout the different stages of the network. ",
+        "bbox": [
+            174,
+            396,
+            825,
+            535
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Another finding in line with this implication of the iterative estimation view is that in some cases sharing weights of the Residual blocks within a stage doesn’t deteriorate performance much (Liao & Poggio, 2016). Similarly Lu & Renals (2015) shared the weights of the transform and carry gates of a thin and deep highway network, while still achieving better performance than both normal deep neural networks and Residual networks. ",
+        "bbox": [
+            174,
+            541,
+            825,
+            611
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.4 REVISITING EVIDENCE AGAINST THE REPRESENTATION VIEW ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            628,
+            640,
+            643
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Staying Close to the Inputs. When iteratively re-estimating a variable, staying close to the old value should be a more common operation than changing it significantly. This is the reason why the ResNet formulation makes sense: learning the identity is hard and it is needed frequently. It also explains sparse transform gate activity in trained Highway networks: These networks learn to dynamically and selectively update individual features, while keeping most of the representation intact. ",
+        "bbox": [
+            174,
+            655,
+            825,
+            738
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Lesioning. Another implication of the iteration view is that processing in layers is incremental and somewhat interchangeable. Each layer (apart from the first) refines an already reasonable estimate of the representation. It follows that removing layers, like in the lesioning experiments, should have only a mild effect on the final result because doing so does not change the overall representation the next layer receives, only its quality. The following layer can still perform mostly the same operation, even with a somewhat noisy input. Layer dropout (Huang et al., 2016b) amplifies this effect by explicitly training the network to work with a variable number of iterations. By dropping random layers it further penalizes iterations relying on each other, which could be another explanation for the regularization effect of the technique. ",
+        "bbox": [
+            174,
+            753,
+            825,
+            880
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Shuffling. The layers within a stage should also be interchangeable to a certain degree, because they all work with the same input and output representations. Of course, this interchangeability is not without limitations. The network could learn to depend on a specific order of refinements, which would be disturbed by shuffling and lesioning. But we can expect these effects to be moderate in many cases, which is indeed what has been reported in the literature. ",
+        "bbox": [
+            173,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/53aaba70039d1f7096c1c25a78b2f216d43501d996430e0588a1c80cc9c11a0c.jpg",
+        "table_caption": [
+            "Table 1: Comparison of several Highway network and Residual network variants. "
+        ],
+        "table_footnote": [
+            "(a) Comparing of various variants of the Highway formulation for character-aware neural language models (Kim et al., 2015). "
+        ],
+        "table_body": "<table><tr><td>Variant</td><td>Functional Form</td><td>Perplexity</td></tr><tr><td>Plain</td><td>H(x)</td><td>92.60</td></tr><tr><td>Residual</td><td>H(x)+x</td><td>91.32</td></tr><tr><td>T-Only</td><td>H(x):T(x) + x</td><td>82.94</td></tr><tr><td>C-Only</td><td>H(x)+x.C(x)</td><td>79.15</td></tr><tr><td>Coupled</td><td>H(x):T(x)+x·(1-T(x))</td><td>79.13</td></tr><tr><td>Full</td><td>H(x)·T(x)+x:C(x)</td><td>79.09</td></tr></table>",
+        "bbox": [
+            173,
+            101,
+            560,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/88161ec5d0844a1b1564431bb53489dd9ba6ca321d3c8ced13c3a5aee03a0353.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "(b) Comparing ILSVRC-2012 top5 classification error. Mean and std over 3 runs. "
+        ],
+        "table_body": "<table><tr><td>Variant</td><td>Top5 Error</td></tr><tr><td>Highway</td><td>10.03 ± 0.17</td></tr><tr><td>Highway-Full</td><td>10.21 ± 0.03</td></tr><tr><td>Resnet</td><td>9.40 ± 0.18</td></tr><tr><td>Highway + BN</td><td>7.53 ± 0.05</td></tr><tr><td>Highway-Full + BN</td><td>7.29 ± 0.11</td></tr><tr><td>Resnet+BN</td><td>7.17 ± 0.14</td></tr></table>",
+        "bbox": [
+            581,
+            101,
+            841,
+            214
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            297,
+            825,
+            339
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 COMPARATIVE CASE STUDIES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            359,
+            459,
+            376
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The preceding sections show that we can construct both Highway and Residual architectures mathematically grounded in learning unrolled iterative estimation. The common feature between these architectures is that they preserve feature identities, and the primary difference is that they have different biases towards switching feature identities. Unfortunately, since our current understanding of the computations required to solve complex problems is limited, it is extremely hard to say a priori which architecture may be more suitable for which type of problems. Therefore, in this section we perform two case studies comparing and contrasting their behavior experimentally. The studies are each based on applications for which Residual and Highway layers respectively have been effective. ",
+        "bbox": [
+            174,
+            391,
+            825,
+            502
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5.1 IMAGE CLASSIFICATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            520,
+            383,
+            534
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Deep Residual networks outperformed all other entries at the 2016 ImageNet classification challenge. In this study we compare the performance of 50-layer convolutional Highway and Residual networks for ImageNet classification. Our aim is not to examine the importance of depth for this task— shallower networks have already outperformed deep Residual networks on all original Residual network benchmarks (Huang et al., 2016a; Szegedy et al., 2016). Instead, our goal is to fairly compare the two architectures, and test the following claims regarding deep convolutional Highway networks (He et al., 2015; 2016; Veit et al., 2016): ",
+        "bbox": [
+            174,
+            545,
+            826,
+            643
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "1. They are harder to train, leading to stalled training or poor results.   \n2. They require extensive tuning of the initial bias, and even then produce much worse results compared to Residual networks.   \n3. They are wasteful in terms of parameters since they utilize extra learned gates, doubling the total parameters for the same number of units compared to a Residual layer. ",
+        "bbox": [
+            210,
+            655,
+            825,
+            732
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We train a 50-layer convolutional Highway network based on the 50-layer Residual network from He et al. (2015). The design of the two networks are identical (including use of batch normalization (BN) after every convolution operation), except that unlike Residual blocks, the Highway blocks use two sets of layers to learn $H$ and $T$ and then combine them using the coupled Highway formulation. We train two slight variations of the Highway network: Highway, in which $H$ has the same design as in a Residual block before addition i.e. Conv-BN-ReLU-Conv-BN-ReLU-Conv-BN, and Highway-Full, in which an additional third ReLU operation is added. The design of $T$ is Conv-BN-ReLU-Conv-BN-ReLU-Conv-BN-Sigmoid. As proposed initially for Highway layers, both $H$ and $T$ are learned using the same receptive fields and number of parameters. The transform gate biases are set to $- 1$ at the start of training. For fair comparison, the number of feature maps throughout the Highway network is reduced such that the total number of parameters is close to the Residual network. The training algorithm and learning rate schedule are kept the same as those used for the Residual network. ",
+        "bbox": [
+            173,
+            743,
+            825,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The plots in Figure 5a show that the Residual network fits the data better—its final training loss is lower than the Highway network. The final performance of both networks on the validation set (see Table 1b) is very similar, with the Residual network producing a slightly better top-5 classification error of $7 . 1 7 \\%$ vs. $7 . 5 3 \\%$ for the Highway network. The Highway-Full network produces even closer results with a mean error of $7 . 2 9 \\%$ . These results contradict claims 1 and 2 above, since the Highway networks are easy to train without requiring any bias tuning. However, there is some support for claim 3 since the Highway network appears to slightly underfit compared to the Residual network, suggesting lower capacity for the same number of parameters. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            215
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Importance of Expressive Gating. The mismatch between the results above and claims 1 and 2 made by He et al. (2016) can be explained based on the importance of having sufficiently expressive transform gates. For experiments with Highway networks (which they refer to as Residual networks with exclusive gating), He et al. (2016) used $1 \\times 1$ convolutions for the transform gate, instead of having the same receptive fields for the gates as the primary transformation $( H )$ , as done by Srivastava et al. (2015a). This change in design appears to be the primary cause of instabilities in learning since the gates can no longer function effectively. Therefore, it is important to use equally expressive transformations for $H$ and $T$ in Highway networks. ",
+        "bbox": [
+            174,
+            231,
+            825,
+            342
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Role of Batch Normalization. Since both architectures have built-in ease of optimization compared to plain networks, it is interesting to investigate the necessity of batch normalization for training these networks. Our derivation in Section 3.2 suggest that BN in Residual networks could take the role of an inductive bias towards iterative estimation by keeping the expected mean of the residual zero (cf. Equation 9). To investigate its role we train the networks above without any batch normalization. The resulting training curves are shown in Figure 5b of the supplementary. ",
+        "bbox": [
+            174,
+            358,
+            825,
+            443
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "We find that without BN both networks reach an even lower training error than before while performing worse on the validation set indicating increased overfitting for both. This shows that BN is not necessary for training these networks and does not speed up learning. Interestingly, the effect is more pronounced for the Highway network, which now fits the data better than the ResNet. This contradicts claim 3, since a Highway network with the same number of parameters as a Residual network demonstrates slightly higher capacity. On the other hand both networks produce a higher validation error— $1 0 . 0 3 \\%$ and $9 . 4 \\bar { 0 } \\%$ for the Highway and Residual network respectively—indicating a clear case of overfitting. This means that batch normalization provides regularization benefits that can’t easily be explained by either improved optimization nor by the inductive bias for Residual networks. ",
+        "bbox": [
+            174,
+            449,
+            825,
+            588
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "5.2 LANGUAGE MODELING ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            606,
+            377,
+            621
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Next we compare different functional forms (or variants) of the Highway network formulation for the case of character-aware language modeling. Kim et al. (2015) have shown that utilizing a few Highway fully connected layers instead of conventional plain layers improves model performance for a variety of languages. The architecture consists of a stack of convolutional layers followed by Highway layers and then an LSTM layer which predicts the next word based on the history. Similar architectures have since been utilized for obtaining substantial improvements for large-scale language modeling (Jozefowicz et al., 2016) and character level machine translation (Lee et al., 2016). Highway layers with coupled gates have been used in all these studies. ",
+        "bbox": [
+            174,
+            632,
+            825,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Only two to four Highway layers were necessary to obtain significant modeling improvements in the studies above. Thus, it is reasonable to assume that the central advantage of using Highway layers for this task is not easing of credit assignment over depth, but an improved modeling bias. To test how well Residual and other variants of Highway networks perform, we compare several language models trained on the Penn Treebank dataset using the same setup and code provided by Kim et al. (2015). We use the LSTM-Char-Large model, only changing the two Highway layers to different variants. The following variants are tested: ",
+        "bbox": [
+            174,
+            751,
+            825,
+            848
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Full The original Highway formulation based on the LSTM cell. We note that this variant uses more parameters than the others, since changing the layer size to reduce parameters would affect the rest of the network architecture as well. ",
+        "bbox": [
+            174,
+            862,
+            825,
+            904
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Coupled The most commonly used Highway variant, derived in Section 3.3. ",
+        "bbox": [
+            173,
+            909,
+            678,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "C-Only A Highway variant with a carry gate but no transform gate (always set to one). ",
+        "bbox": [
+            174,
+            103,
+            745,
+            118
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "T-Only A Highway variant with a transform gate but no carry gate (always set to one). ",
+        "bbox": [
+            174,
+            122,
+            743,
+            137
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Residual The Residual form from He et al. (2015), in which both transform and carry gate are always one. For this variant we use four layers instead of two, to match the amount of computation/parameters of the other variants. ",
+        "bbox": [
+            173,
+            142,
+            825,
+            184
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The test set perplexity of each model is shown in Table 1a. We find that the the Full, Coupled and C-Only variants have similar performance, better than the T-Only variant and substantially better than the Residual variant. The Residual variant results in performance close to that obtained by using a single plain layer, even though four Residual layers are used. Learned gating of the identity connection is crucial for improving performance for this task. ",
+        "bbox": [
+            174,
+            196,
+            825,
+            267
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Recall that the Highway layers transform character-aware representations before feeding them into an LSTM layer. Thus the non-contextual word-level representations resulting from the convolutional layers are transformed into representations better suited for contextual language modeling. Since it is unlikely that the entire representation needs to change completely, this setting fits well with the iterative estimation perspective. ",
+        "bbox": [
+            174,
+            275,
+            825,
+            344
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Interestingly, Table 1a shows a significant advantage for all variants with a multiplicative gate on the inputs. These results suggest that in this setting it is crucial to dynamically replace parts of the input representation. Some features need to be changed drastically conditioned on other detected features such as word type while other features need to be retained. As a result, even though Residual networks are compatible with iterative estimation, they may not be the best choice for tasks where mixing adaptive feature transform/replacement and reuse is required. ",
+        "bbox": [
+            174,
+            351,
+            825,
+            435
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "6 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            455,
+            318,
+            472
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This paper offers a new perspective on Highway and Residual networks as performing unrolled iterative estimation. As an extension of the popular representation view, it stands in contrast to the optimization perspective from which these architectures have originally been introduced. According to the new view, successive layers (within a stage) cooperate to compute a single level of representation. Therefore, the first layer already computes a rough estimate of that representation, which is then iteratively refined by the successive layers. Unlike layers in a conventional neural network, which each compute a new representation, these layers therefore preserve feature identity. ",
+        "bbox": [
+            174,
+            487,
+            825,
+            585
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We have further shown that both Residual and Highway networks can be directly derived from this new perspective. This offers a unified theory from which these architectures can be understood as two approaches to the same problem. This view further provides a framework from which to understand several surprising recent findings like resilience to lesioning, benefits of layer dropout, and the mild negative effects of layer reshuffling. Together with the derivations these results serve as compelling evidence for the validity of our new perspective. ",
+        "bbox": [
+            174,
+            592,
+            825,
+            675
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Motivated by their conceptual similarities we set out to compare Highway and Residual networks. In preliminary experiments we found that they give very similar results for networks of equal size, thus refuting some claims that Highway networks would need more parameters, or that any form of gating impairs the performance of Residual networks. In another example, we found non-gated identity skip-connections to perform significantly worse, and offered a possible explanation: If the task requires dynamically replacing individual features, then the use of gating is beneficial. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            766
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The preliminary evidence presented in this report is meant as a starting point for further investigation. We hope that the unrolled iterative estimation perspective will provide valuable intuitions to help guide research into understanding, improving and possibly combining these exciting techniques. ",
+        "bbox": [
+            174,
+            773,
+            825,
+            815
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGEMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            367,
+            852
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "The authors wish to thank Faustino Gomez, Bas Steunebrink, Jonathan Masci, Sjoerd van Steenkiste and Christian Osendorfer for their feedback and support. We are grateful to NVIDIA Corporation for providing us a DGX-1 as part of the Pioneers of AI Research award. This research was supported by the EU project “INPUT” (H2020-ICT-2015 grant no. 687795). ",
+        "bbox": [
+            176,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nAbdi, Masoud and Nahavandi, Saeid. Multi-Residual Networks. arXiv:1609.05672 [cs], September 2016.   \nChu, Brian, Yang, Daylen, and Tadinada, Ravi. Visualizing Residual Networks. arXiv:1701.02362 [cs], January 2017.   \nDeng, Li and Yu, Dong. Deep Learning Methods and Applications. Foundations and Trends in Signal Processing, pp. 199–200, 2014.   \nGoodfellow, Ian, Bengio, Yoshua, and Courville, Aaron. Deep Learning. Book in preparation for MIT Press, 2016.   \nHe, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Deep Residual Learning for Image Recognition. arXiv:1512.03385 [cs], December 2015.   \nHe, Kaiming, Zhang, Xiangyu, Ren, Shaoqing, and Sun, Jian. Identity Mappings in Deep Residual Networks. In Computer Vision–ECCV 2016, 2016.   \nHochreiter, Sepp. Untersuchungen zu dynamischen neuronalen Netzen. Diploma, Technische Universität München, pp. 91, 1991.   \nHochreiter, Sepp and Schmidhuber, Jürgen. Long short-term memory. Neural computation, 9(8): 1735–1780, 1997.   \nHuang, Gao, Liu, Zhuang, and Weinberger, Kilian Q. Densely Connected Convolutional Networks. arXiv:1608.06993 [cs], August 2016a.   \nHuang, Gao, Sun, Yu, Liu, Zhuang, Sedra, Daniel, and Weinberger, Kilian. Deep Networks with Stochastic Depth. arXiv:1603.09382 [cs], March 2016b.   \nHubel, David H. and Wiesel, Torsten N. Receptive fields, binocular interaction and functional architecture in the cat’s visual cortex. The Journal of physiology, 160(1):106–154, 1962.   \nJozefowicz, Rafal, Vinyals, Oriol, Schuster, Mike, Shazeer, Noam, and Wu, Yonghui. Exploring the limits of language modeling. arXiv preprint arXiv:1602.02410, 2016.   \nKim, Yoon, Jernite, Yacine, Sontag, David, and Rush, Alexander M. Character-aware neural language models. arXiv preprint arXiv:1508.06615, 2015.   \nLeCun, Yann, Bengio, Yoshua, and Hinton, Geoffrey. Deep learning. Nature, 521(7553):436–444, May 2015. ISSN 0028-0836. doi: 10.1038/nature14539.   \nLee, Jason, Cho, Kyunghyun, and Hofmann, Thomas. Fully Character-Level Neural Machine Translation without Explicit Segmentation. arXiv preprint arXiv:1610.03017, 2016.   \nLiao, Qianli and Poggio, Tomaso. Bridging the Gaps Between Residual Learning, Recurrent Neural Networks and Visual Cortex. arXiv:1604.03640 [cs], April 2016.   \nLu, Liang and Renals, Steve. Small-footprint Deep Neural Networks with Highway Connections for Speech Recognition. arXiv:1512.04280 [cs], December 2015.   \nSchmidhuber, Jürgen. Deep learning in neural networks: An overview. Neural Networks, 61:85–117, January 2015. ISSN 0893-6080. doi: 10.1016/j.neunet.2014.09.003.   \nSpringenberg, Jost Tobias, Dosovitskiy, Alexey, Brox, Thomas, and Riedmiller, Martin. Striving for Simplicity: The All Convolutional Net. arXiv:1412.6806 [cs], December 2014.   \nSrivastava, Rupesh K, Greff, Klaus, and Schmidhuber, Juergen. Training Very Deep Networks. In Cortes, C., Lawrence, N. D., Lee, D. D., Sugiyama, M., and Garnett, R. (eds.), Advances in Neural Information Processing Systems 28, pp. 2377–2385. Curran Associates, Inc., 2015a.   \nSrivastava, Rupesh Kumar, Greff, Klaus, and Schmidhuber, Jürgen. Highway Networks. arXiv:1505.00387 [cs], May 2015b. ",
+        "bbox": [
+            171,
+            87,
+            828,
+            924
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Szegedy, Christian, Ioffe, Sergey, Vanhoucke, Vincent, and Alemi, Alex. Inception-v4, InceptionResNet and the Impact of Residual Connections on Learning. arXiv:1602.07261 [cs], February 2016. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Veit, Andreas, Wilber, Michael, and Belongie, Serge. Residual Networks are Exponential Ensembles of Relatively Shallow Networks. arXiv:1605.06431 [cs], May 2016. ",
+        "bbox": [
+            171,
+            155,
+            823,
+            184
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zeiler, Matthew D. and Fergus, Rob. Visualizing and understanding convolutional networks. In European Conference on Computer Vision, pp. 818–833. Springer, 2014. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zilly, Julian Georg, Srivastava, Rupesh Kumar, Koutník, Jan, and Schmidhuber, Jürgen. Recurrent Highway Networks. arXiv:1607.03474 [cs], July 2016. ",
+        "bbox": [
+            173,
+            231,
+            823,
+            260
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/f0a9278a7a7c56b67639b1d680b954144ef134bf734070b5cf2e8ec24142110b.jpg",
+        "image_caption": [
+            "Figure 5: Comparing 50-layer Highway vs. Residual networks on ILSVRC-2012 classification. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            113,
+            797,
+            473
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A DERIVATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            522,
+            316,
+            539
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A.1 OPTIMAL LINEAR ESTIMATOR ",
+        "bbox": [
+            176,
+            553,
+            429,
+            568
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Assume two random variables $A$ and $B$ that are both noisy measurements of a third (latent) random variable $C$ : ",
+        "bbox": [
+            171,
+            579,
+            825,
+            607
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ce2dcbd445360ebc92e7be8bb5d81d3b70f97a34c8a192c52ac79cc4779974c7.jpg",
+        "text": "$$\n\\mathbb { E } [ A - C ] = \\mathbb { E } [ B - C ] = 0\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            606,
+            594,
+            623
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We call the corresponding variances $\\mathrm { V a r } [ A - C ] = \\sigma _ { A } ^ { 2 }$ and $\\mathrm { V a r } [ B - C ] = \\sigma _ { B } ^ { 2 }$ and covariance Cov[A, B] = σ2AB . ",
+        "bbox": [
+            174,
+            625,
+            826,
+            655
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We are looking for the linear estimator $q ( A , B ) = q _ { 0 } + q _ { 1 } A + q _ { 2 } B$ of $C$ with $\\mathbb { E } [ q - C ] = 0$ (unbiased) that has minimum variance. ",
+        "bbox": [
+            173,
+            659,
+            823,
+            689
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/48ec35c1a97e27eba875f331e7aa7cae630b656709498d5de2e2cbb5b6c6cb2e.jpg",
+        "text": "$$\n\\begin{array} { r } { \\mathbb { E } [ q ( A , B ) - C ] = 0 } \\\\ { \\mathbb { E } [ q _ { 0 } + q _ { 1 } A + q _ { 2 } B - C ] = 0 } \\\\ { \\mathbb { E } [ q _ { 0 } + q _ { 1 } A - q _ { 1 } C + q _ { 2 } B - q _ { 2 } C + ( q _ { 1 } + q _ { 2 } - 1 ) C ] = 0 } \\\\ { \\mathbb { E } [ q _ { 0 } + q _ { 1 } ( A - C ) + q _ { 2 } ( B - C ) + ( q _ { 1 } + q _ { 2 } - 1 ) C ] = 0 } \\\\ { q _ { 0 } + ( q _ { 1 } + q _ { 2 } - 1 ) \\mathbb { E } [ C ] = 0 } \\\\ { \\mathbb { E } [ C ] ( 1 - q _ { 1 } - q _ { 2 } ) = q _ { 0 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            305,
+            712,
+            691,
+            820
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "for all $\\mathbb { E } [ C ]$ which is possible iff: ",
+        "bbox": [
+            173,
+            821,
+            393,
+            837
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/4e52a287caf62440e5ffcbd7f6c4d2ff9a563147ff0676a966fca450c17e90c0.jpg",
+        "text": "$$\nq _ { 0 } = 0 \\mathrm { a n d } q _ { 1 } + q _ { 2 } = 1 .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            842,
+            580,
+            857
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "The second condition about minimal variance thus reduces to: ",
+        "bbox": [
+            173,
+            868,
+            581,
+            883
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9eb8825476a1f85e1483df26cfab31e40b714fd21810fb12082d4ace925e51ca.jpg",
+        "text": "$$\n\\begin{array} { r l } { \\underset { q _ { 1 } , q _ { 2 } } { \\operatorname { m i n i m i z e } } } & { { } \\mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] } \\\\ { \\mathrm { s u b j e c t } \\mathrm { t o } } & { { } q _ { 1 } + q _ { 2 } = 1 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            382,
+            885,
+            614,
+            928
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "We can solve this using Lagrangian multipliers. For that we need to take the derivative of the following term w.r.t. $q _ { 1 } , q _ { 2 }$ and $\\lambda$ and set them to zero: ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/69c22521235c1aee6a45276afdbde7dbac7f10db042cd629e6f590d50f7bfb52.jpg",
+        "text": "$$\n\\mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] - \\lambda ( q _ { 1 } + q _ { 2 } - 1 ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            138,
+            633,
+            156
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "The first equation is therefore: ",
+        "bbox": [
+            173,
+            170,
+            374,
+            185
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f612be4800058d9ce3a960acf4bc8f36d495f444681692e22246e1da6409bdb9.jpg",
+        "text": "$$\n\\begin{array} { r l r } & { } & { \\frac { d } { d q _ { 1 } } ( \\mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] - \\lambda ( q _ { 1 } + q _ { 2 } - 1 ) ) = 0 } \\\\ & { } & { \\frac { d } { d q _ { 1 } } \\mathrm { V a r } [ q _ { 1 } A + q _ { 2 } B - C ] - \\lambda = 0 } \\\\ & { } & { \\frac { d } { d q _ { 1 } } \\mathrm { V a r } [ q _ { 1 } ( A - C ) + q _ { 2 } ( B - C ) ] - \\lambda = 0 } \\\\ & { } & { \\frac { d } { d q _ { 1 } } ( q _ { 1 } ^ { 2 } \\mathrm { V a r } [ A - C ] + 2 q _ { 1 } q _ { 2 } \\mathrm { C o v } [ A - C , B - C ] ) - \\lambda = 0 } \\\\ & { } & { 2 q _ { 1 } \\sigma _ { A } ^ { 2 } + 2 q _ { 2 } \\sigma _ { A B } ^ { 2 } - \\lambda = 0 } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            190,
+            697,
+            347
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Analogously we get: ",
+        "bbox": [
+            174,
+            351,
+            310,
+            364
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "and: ",
+        "bbox": [
+            173,
+            383,
+            204,
+            397
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/943a2dc5ac735a659c9c8ffcc0c4349cb0ac5a89467ae84c7a2528b7ec40b3f9.jpg",
+        "text": "$$\n\\begin{array} { c } { { 2 q _ { 2 } \\sigma _ { B } ^ { 2 } + 2 q _ { 1 } \\sigma _ { A B } ^ { 2 } - \\lambda = 0 } } \\\\ { { { } } } \\\\ { { q _ { 1 } + q _ { 2 } = 1 } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            408,
+            359,
+            588,
+            415
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Solving these equations gives us: ",
+        "bbox": [
+            173,
+            422,
+            392,
+            438
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5eda67b76f7b95956e6e98f75d2fee1d03098c9748f487c44701f5d67fa6b19c.jpg",
+        "text": "$$\n\\begin{array} { c } { { q _ { 1 } = \\displaystyle \\frac { \\sigma _ { B } ^ { 2 } - \\sigma _ { A B } ^ { 2 } } { \\sigma _ { A } ^ { 2 } - 2 \\sigma _ { A B } ^ { 2 } + \\sigma _ { B } ^ { 2 } } } } \\\\ { { q _ { 2 } = \\displaystyle \\frac { \\sigma _ { A } ^ { 2 } - \\sigma _ { A B } ^ { 2 } } { \\sigma _ { A } ^ { 2 } - 2 \\sigma _ { A B } ^ { 2 } + \\sigma _ { B } ^ { 2 } } } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            416,
+            444,
+            581,
+            518
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "We can write our estimator in terms of $\\alpha _ { 1 } = \\sigma _ { B } ^ { 2 } - \\sigma _ { A B } ^ { 2 }$ and $\\alpha _ { 2 } = \\sigma _ { A } ^ { 2 } - \\sigma _ { A B } ^ { 2 }$ : ",
+        "bbox": [
+            171,
+            547,
+            687,
+            566
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/dd68680620a16b5704f226c4fb1434bd9b275c74c65409839baf773fd4393113.jpg",
+        "text": "$$\nq = \\frac { \\alpha _ { 1 } } { \\alpha _ { 1 } + \\alpha _ { 2 } } A + \\frac { \\alpha _ { 2 } } { \\alpha _ { 1 } + \\alpha _ { 2 } } B\n$$",
+        "text_format": "latex",
+        "bbox": [
+            400,
+            570,
+            599,
+            602
+        ],
+        "page_idx": 13
+    }
+]

parse/train/rJe4_xSFDB/rJe4_xSFDB.md

@@ -0,0 +1,419 @@
+# LIPSCHITZ CONSTANT ESTIMATION OF NEURAL NETWORKS VIA SPARSE POLYNOMIAL OPTIMIZATION
+
+Fabian Latorre, Paul Rolland and Volkan Cevher EPFL, Switzerland firstname.lastname@epfl.ch
+
+# ABSTRACT
+
+We introduce LiPopt, a polynomial optimization framework for computing increasingly tighter upper bounds on the Lipschitz constant of neural networks. The underlying optimization problems boil down to either linear (LP) or semidefinite (SDP) programming. We show how to use the sparse connectivity of a network, to significantly reduce the complexity of computation. This is specially useful for convolutional as well as pruned neural networks. We conduct experiments on networks with random weights as well as networks trained on MNIST, showing that in the particular case of the $\ell _ { \infty }$ -Lipschitz constant, our approach yields superior estimates, compared to baselines available in the literature.
+
+# 1 INTRODUCTION
+
+We consider a neural network $f _ { d }$ defined by the recursion:
+
+$$
+f _ { 1 } ( x ) : = W _ { 1 } x \qquad f _ { i } ( x ) : = W _ { i } \sigma ( f _ { i - 1 } ( x ) ) , \quad i = 2 , \ldots , d
+$$
+
+for an integer $d$ larger than 1, matrices $\{ W _ { i } \} _ { i = 1 } ^ { d }$ of appropriate dimensions and an activation function $\sigma$ , understood to be applied element-wise. We refer to $d$ as the depth, and we focus on the case where $f _ { d }$ has a single real value as output.
+
+In this work, we address the problem of estimating the Lipschitz constant of the network $f _ { d }$ . A function $f$ is Lipschitz continuous with respect to a norm $\left\| \cdot \right\|$ if there exists a constant $L$ such that for all $x , y$ we have $| f ( x ) - f ( y ) | \leq L \| x - y \|$ . The minimum over all such values satisfying this condition is called the Lipschitz constant of $f$ and is denoted by $L ( f )$ .
+
+The Lipschitz constant of a neural network is of major importance in many successful applications of deep learning. In the context of supervised learning, Bartlett et al. (2017) show how it directly correlates with the generalization ability of neural network classifiers, suggesting it as model complexity measure. It also provides a measure of robustness against adversarial perturbations (Szegedy et al., 2014) and can be used to improve such metric (Cisse et al., 2017). Moreover, an upper bound on $L ( f _ { d } )$ provides a certificate of robust classification around data points (Weng et al., 2018).
+
+Another example is the discriminator network of the Wasserstein GAN (Arjovsky et al., 2017), whose Lipschitz constant is constrained to be at most 1. To handle this constraint, researchers have proposed different methods like heuristic penalties (Gulrajani et al., 2017), upper bounds (Miyato et al., 2018), choice of activation function (Anil et al., 2019), among many others. This line of work has shown that accurate estimation of such constant is key to generating high quality images.
+
+Lower bounds or heuristic estimates of $L ( f _ { d } )$ can be used to provide a general sense of how robust a network is, but fail to provide true certificates of robustness to input perturbations. Such certificates require true upper bounds, and are paramount when deploying safety-critical deep reinforcement learning applications (Berkenkamp et al., 2017; Jin & Lavaei, 2018). The trivial upper bound given by the product of layer-wise Lipschitz constants is easy to compute but rather loose and overly pessimistic, providing poor insight into the true robustness of a network (Huster et al., 2018).
+
+Indeed, there is a growing need for methods that provide tighter upper bounds on $L ( f _ { d } )$ , even at the expense of increased complexity. For example Raghunathan et al. (2018a); Jin & Lavaei (2018); Fazlyab et al. (2019) derive upper bounds based on semidefinite programming $( S D P )$ . While expensive to compute, these type of certificates are in practice surprisingly tight. Our work belongs in this vein of research, and aims to overcome some limitations in the current state-of-the-art.
+
+# Our Contributions.
+
+. We present LiPopt, a general approach for upper bounding the Lipschitz constant of a neural network based on a relaxation to a polynomial optimization problem (POP) (Lasserre, 2015). This approach requires only that the unit ball be described with polynomial inequalities, which covers the common $\ell _ { 2 ^ { - } }$ and $\ell _ { \infty }$ -norms. . Based on a theorem due to Weisser et al. (2018), we exploit the sparse connectivity of neural network architectures to derive a sequence of linear programs (LPs) of considerably smaller size than their vanilla counterparts. We provide an asymptotic analysis of the size of such programs, in terms of the number of neurons, depth and sparsity of the network. . Focusing on the $\ell _ { \infty }$ -norm, we experiment on networks with random weights and networks trained on MNIST (Lecun et al., 1998). We evaluate different configurations of depth, width and sparsity and we show that the proposed sequence of LPs can provide tighter upper bounds on $\dot { L } ( f _ { d } )$ compared to other baselines available in the literature.
+
+Notation. We denote by $n _ { i }$ the number of columns of the matrix $W _ { i }$ in the definition (1) of the network. This corresponds to the size of the $i$ -th layer, where we identify the input as the first layer. We let $n = n _ { 1 } + . . . + n _ { d }$ be the total number of neurons in the network. For a vector $x$ , $\operatorname { D i a g } ( x )$ denotes the square matrix with $x$ in its diagonal and zeros everywhere else. For an array $X$ , $\operatorname { v e c } ( X )$ is the flattened array. The support of a sequence $\operatorname { s u p p } ( \alpha )$ is defined as the set of indices $j$ such that $\alpha _ { j }$ is nonnote by o. For the m $x = [ x _ { 1 } , \ldots , x _ { n } ]$ a sequence of nonnegative integers . The set of nonnegative integers is $\gamma = [ \gamma _ { 1 } , \dotsc , \gamma _ { n } ]$ we $x ^ { \gamma }$ $x _ { 1 } ^ { \gamma _ { 1 } } x _ { 2 } ^ { \gamma _ { 2 } } \ldots x _ { n } ^ { \gamma _ { n } }$ $\mathbb { N }$
+
+Remark. The definition of network (1) covers typical architectures composed of dense and convolutional layers. In general, our proposed approach can be readily extended with minor modifications to any directed acyclic computation graph e.g., residual network architectures (He et al., 2016).
+
+# 2 POLYNOMIAL OPTIMIZATION FORMULATION
+
+In this section we derive an upper bound on $L ( f _ { d } )$ given by the value of a POP, i.e. the minimum value of a polynomial subject to polynomial inequalities. Our starting point is the following theorem, which casts $\dot { L } ( f )$ as an optimization problem:
+
+Theorem 1. Let $f$ be a differentiable and Lipschitz continuous function on an open, convex subset $\mathcal { X }$ of an euclidean space. Let $\left\| \cdot \right\| _ { * }$ be the dual norm. The Lipschitz constant of $f$ is given by
+
+$$
+L ( f ) = \operatorname* { s u p } _ { x \in \mathcal { X } } \| \nabla f ( x ) \| _ { * }
+$$
+
+For completeness, we provide a proof in appendix A. In our setting, we assume that the activation function $\sigma$ is Lipschitz continuous and differentiable. In this case, the assumptions of Theorem 1 are fulfilled because $f _ { d }$ is a composition of activations and linear transformations. The differentiability assumption rules out the common ReLU activation $\sigma ( x ) = \operatorname* { m a x } \{ 0 , x \}$ , but allows many others such as the exponential linear unit (ELU) (Clevert et al., 2015) or the softplus.
+
+Using the chain rule, the compositional structure of $f _ { d }$ yields the following formula for its gradient:
+
+$$
+\nabla f _ { d } ( x ) = W _ { 1 } ^ { T } \prod _ { i = 1 } ^ { d - 1 } \operatorname { D i a g } ( \sigma ^ { \prime } ( f _ { i } ( x ) ) ) W _ { i + 1 } ^ { T }
+$$
+
+For every $i = 1 , \ldots , d - 1$ we introduce a variable $s _ { i } = \sigma ^ { \prime } ( f _ { i } ( x ) )$ corresponding to the derivative of $\sigma$ at the $i$ -th hidden layer of the network. For activation functions like ELU or softplus, their derivative is bounded between 0 and 1, which implies that $0 \leq s _ { i } \leq 1$ . This bound together with the definition of the dual norm $\| x \| _ { * } : = \operatorname* { s u p } _ { \| t \| \leq 1 } t ^ { T } \bar { x }$ implies the following upper bound of $L ( f _ { d } )$ :
+
+$$
+L ( f _ { d } ) \leq \operatorname* { m a x } \left\{ t ^ { T } W _ { 1 } ^ { T } \prod _ { i = 1 } ^ { d - 1 } \operatorname { D i a g } ( s _ { i } ) W _ { i + 1 } ^ { T } : 0 \leq s _ { i } \leq 1 , \| t \| \leq 1 \right\}
+$$
+
+We will refer to the polynomial objective of this problem as the norm-gradient polynomial of the network $f _ { d }$ , a central object of study in this work.
+
+For some frequently used $\ell _ { p }$ -norms, the constraint $\| t \| _ { p } \leq 1$ can be written with polynomial inequalities. In the rest of this work, we use exclusively the $\ell _ { \infty }$ -norm for which $\| t \| _ { \infty } \dot { \leq } 1$ is equivalent to the polynomial inequalities $- 1 \leq t _ { i } \leq 1$ , for $i = 1 , \ldots , n _ { 1 }$ . However, note that when $p \geq 2$ is a positive even integer, $\| t \| _ { p } \leq 1$ is equivalent to a single polynomial inequality $\| t \| _ { p } ^ { p } \leq 1$ , and our proposed approach can be adapted with minimal modifications.
+
+In such cases, the optimization problem in the right-hand side of (4) is a POP. Optimization of polynomials is a NP-hard problem and we do not expect to have efficient algorithms for solving (4) in this general form. In the next sections we describe LiPopt: a systematic way of obtaining an upper bound on $L ( f _ { d } )$ via tractable approximation methods of the POP (4).
+
+Local estimation. In many practical escenarios, we have additional bounds on the input of the network. For example, in the case of image classification tasks, valid input is constrained in a hypercube. In the robustness certification task, we are interested in all possible input in a $\epsilon$ -ball around some data point. In those cases, it is interesting to compute a local Lipschitz constant, that is, the Lipschitz constant of a function restricted to a subset.
+
+We can achieve this by deriving tighter bounds $0 \leq l _ { i } \leq s _ { i } \leq u _ { i } \leq 1$ , as a consequence of the restricted input (see for example, Algorithm 1 in Wong & Kolter (2018)). By incorporating this knowledge in the optimization problem (4) we obtain bounds on local Lipschitz constants of $f _ { d }$ . We study this setting and provide numerical experiments in section 7.3.
+
+Choice of norm. We highlight the importance of computing good upper bounds on $L ( f _ { d } )$ with respect to the $\ell _ { \infty }$ -norm. It is one of the most commonly used norms to assess robustness in the adversarial examples literature. Moreover, it has been shown that, in practice, $\ell _ { \infty }$ -norm robust networks are also robust in other more plausible measures of perceptibility, like the Wasserstein distance (Wong et al., 2019). This motivates our focus on this choice.
+
+# 3 HIERARCHICAL SOLUTION BASED ON A POLYNOMIAL POSITIVITY CERTIFICATE
+
+For ease of exposition, we rewrite (4) as a POP constrained in $[ 0 , 1 ] ^ { n }$ using the substitution $s _ { 0 } : = ( t +$ $1 ) / 2$ . Denote by $p$ the norm-gradient polynomial, and let $x = [ s _ { 0 } , \ldots , s _ { d - 1 } ]$ be the concatenation of all variables. Polynomial optimization methods (Lasserre, 2015) start from the observation that a value $\lambda$ is an upper bound for $p$ over a set $K$ if and only if the polynomial $\lambda - p$ is positive over $K$ .
+
+In LiPopt, we will employ a well-known classical result in algebraic geometry, the so-called Krivine’s positivity certificate1, but in theory we can use any positivity certificate like sum-of-squares (SOS). The following is a straightforward adaptation of Krivine’s certificate to our setting:
+
+Theorem 2. (Adapted from Krivine (1964); Stengle (1974); Handelman (1988)) If the polynomial $\lambda - p$ is strictly positive on $[ 0 , 1 ] ^ { n }$ , then there exist finitely many positive weights $c _ { \alpha \beta }$ such that
+
+$$
+\lambda - p = \sum _ { ( \alpha , \beta ) \in \mathbb { N } ^ { 2 n } } c _ { \alpha \beta } h _ { \alpha \beta } , \qquad h _ { \alpha \beta } ( x ) : = \prod _ { j = 1 } ^ { n } x _ { j } ^ { \alpha _ { j } } ( 1 - x _ { j } ) ^ { \beta _ { j } }
+$$
+
+By truncating the degree of Krivine’s positivity certificate (Theorem 2) and minimizing over all possible upper bounds $\lambda$ we obtain a hierarchy of LP problems (Lasserre, 2015, Section 9):
+
+$$
+\theta _ { k } : = \operatorname* { m i n } _ { c \geq 0 , \lambda } \left\{ \lambda : \lambda - p = \sum _ { ( \alpha , \beta ) \in \mathbb { N } _ { k } ^ { 2 n } } c _ { \alpha \beta } h _ { \alpha \beta } \right\}
+$$
+
+where $\mathbb { N } _ { k } ^ { 2 n }$ is the set of nonnegative integer sequences of length $2 n$ adding up to at most $k$ . This is indeed a sequence of LPs as the polynomial equality constraint can be implemented by equating coefficients in the canonical monomial basis. For this polynomial equality to be feasible, the degree of the certificate has to be at least that of the norm-gradient polynomial $p$ , which is equal to the depth $d$ . This implies that the first nontrivial bound $( \theta _ { k } < \infty )$ ) corresponds to $k = d$ .
+
+The sequence $\{ \theta _ { k } \} _ { k = 1 } ^ { \infty }$ is non-incresing and converges to the maximum of the upper bound (4). Note that for any level of the hierarchy, the solution of the LP (6) provides a valid upper bound on $L ( f _ { d } )$ .
+
+An advantage of using Krivine’s positivity certificate over SOS is that one obtains an LP hierarchy (rather than SDP), for which commercial solvers can reliably handle a large instances. Other positivity certificates offering a similar advantage are the DSOS and SDSOS hierarchies (Ahmadi & Majumdar, 2019), which boil down to LP or second order cone programming (SOCP), respectively.
+
+Drawback. The size of the LPs given by Krivine’s positivity certificate can become quite large. The dimension of the variable $c$ is $| \mathbb { N } _ { k } ^ { 2 n } | = { \dot { \mathcal { O } } } ( n ^ { k } )$ . For reference, if we consider the MNIST dataset and a one-hidden-layer network with 100 neurons we have $\left| \mathbb { N } _ { 2 } ^ { 2 n } \right| \approx 1 . 5 \times 1 0 ^ { 6 }$ while $\left| \mathbb { N } _ { 3 } ^ { 2 n } \right| \approx 9 . 3 \times 1 0 ^ { 8 }$ . To make this approach more scalable, in the next section we exploit the sparsity of the polynomial $p$ to find LPs of drastically smaller size than (6), but with similar approximation properties.
+
+Remark. In order to compute upper bounds for local Lipschitz constants, first obtain tighter bounds $0 \leq l _ { i } \leq s _ { i } \leq u _ { i }$ and then perform the change of variables $\widetilde { s } _ { i } = ( s _ { i } - l _ { i } ) / ( u _ { i } - l _ { i } )$ to rewrite the problem (4) as a POP constrained on $[ 0 , 1 ] ^ { n }$ .
+
+# 4 REDUCING THE NUMBER OF VARIABLES
+
+Many neural network architectures, like those composed of convolutional layers, have a highly sparse connectivity between neurons. Moreover, it has been empirically observed that up to $90 \%$ of network weights can be pruned (set to zero) without harming accuracy (Frankle & Carbin, 2019). In such cases their norm-gradient polynomial has a special structure that allows polynomial positivity certificates of smaller size than the one given by Krivine’s positivity certificate (Theorem 2).
+
+In this section, we describe an implementation of LiPopt (Algorithm 1) that exploits the sparsity of the network to decrease the complexity of the LPs (6) given by the Krivine’s positivity certificate. In this way, we obtain upper bounds on $L ( f _ { d } )$ that require less computation and memory. Let us start with the definition of a valid sparsity pattern:
+
+Definition 1. Let $I = \{ 1 , \ldots , n \}$ and $p$ be a polynomial with variable $x \in \mathbb { R } ^ { n }$ . A valid sparsity pattern of $p$ is a sequence $\{ I _ { i } \} _ { i = 1 } ^ { m }$ of subsets of $I$ , called cliques, such that $\textstyle \bigcup _ { i = 1 } ^ { m } I _ { i } = I$ and:
+
+. $\textstyle p = \sum _ { i = 1 } ^ { m } p _ { i }$ where $p _ { i }$ is a polynomial that depends only on the variables $\{ x _ { j } : j \in I _ { i } \}$ . for all $i = 1 , \ldots , m - 1$ there is an $l \leq i$ such that $\begin{array} { r } { ( I _ { i + 1 } \cap \bigcup _ { r = 1 } ^ { i } I _ { r } ) \subseteq I _ { l } } \end{array}$
+
+When the polynomial objective $p$ in a POP has a valid sparsity pattern, there is an extension of Theorem 2 due to Weisser et al. (2018), providing a smaller positivity certificate for $\lambda - p$ over $[ 0 , 1 ] ^ { n }$ . We refer to it as the sparse Krivine’s certificate and we include it here for completeness:
+
+Theorem 3 (Adapted from Weisser et al. (2018)). Let a polynomial $p$ have a valid sparsity pattern $\{ I _ { i } \} _ { i = 1 } ^ { m }$ . Define $N _ { i }$ as the set of sequences $( \alpha , \beta ) \in \bar { \mathbb { N } } ^ { 2 n }$ where the support of both $\alpha$ and $\beta$ is contained in $I _ { i }$ . If $\lambda - p$ is strictly positive over $K = [ 0 , 1 ] ^ { n }$ , there exist finitely many positive weights $c _ { \alpha \beta }$ such that
+
+$$
+\lambda - p = \sum _ { i = 1 } ^ { m } h _ { i } , \qquad h _ { i } = \sum _ { ( \alpha , \beta ) \in N _ { i } } c _ { \alpha \beta } h _ { \alpha \beta }
+$$
+
+where the polynomials $h _ { \alpha \beta }$ are defined as in (5).
+
+The sparse Krivine’s certificate can be used like the general version (Theorem 2) to derive a sequence of LPs approximating the upper bound on $L ( f _ { d } )$ stated in (4). However, the number of different polynomials $h _ { \alpha \beta }$ of degree at most $k$ appearing in the sparse certificate can be drastically smaller, the amount of which determines how good the sparsity pattern is.
+
+We introduce a graph that depends on the network $f _ { d }$ , from which we will extract a sparsity pattern for the norm-gradient polynomial of a network.
+
+![](images/214b4ec10db794f93e318582922104545dac5f8d93ae013d25d849c225637e9d.jpg)  
+Figure 1: Sparsity pattern of Proposition 1 for a network of depth three.
+
+![](images/c840ffb3080a0f590ddc61c0b1ed0992fd23d3fa33726a52fedf988a09c2b4b8.jpg)  
+Figure 2: Structure of one set in the sparsity pattern from Proposition 1 for a network with 2D convolutional layers with $3 \times 3$ filters.
+
+Definition 2. Let $f _ { d }$ be a network with weights $\{ W _ { i } \} _ { i = 1 } ^ { d }$ . Define a directed graph $G _ { d } = ( V , E )$ as:
+
+$$
+\begin{array} { c } { { V = \{ s _ { i , j } : 0 \leq i \leq d - 1 , 1 \leq j \leq n _ { i } \} } } \\ { { E = \{ ( s _ { i , j } , s _ { i + 1 , k } ) : 0 \leq i \leq d - 2 , [ W _ { i } ] _ { k , j } \neq 0 \} } } \end{array}
+$$
+
+which we call the computational graph of the network $f _ { d }$
+
+In the graph $G _ { d }$ the vertex $s _ { ( i , j ) }$ represents the $j$ -th neuron in the $i$ -th layer. There is a directed edge between two neurons in consecutive layers if they are joined by a nonzero weight in the network. The following result shows that for fully connected networks we can extract a valid sparsity pattern from this graph. We relegate the proof to appendix B.
+
+Proposition 1. Let $f _ { d }$ be a dense network (all weights are nonzero). The following sets, indexed by $i = 1 , \ldots , n _ { d } ,$ form a valid sparsity pattern for the norm-gradient polynomial of the network $f _ { d }$ :
+
+$$
+I _ { i } : = \left\{ s _ { ( d - 1 , i ) } \right\} \cup \left\{ s _ { ( j , k ) } : t h e r e \ e x i s t s a \ d i r e c t e d p a t h f r o m \ s _ { ( j , k ) } \ t o \ s _ { ( d - 1 , i ) } \ i n \ G _ { d } \right\}
+$$
+
+We refer to this as the sparsity pattern induced by $G _ { d }$ . An example is depicted in in Figure 1.
+
+Remark. When the network is not dense, the the second condition (Definition 1) for the sparsity pattern (9) to be valid might not hold. In that case we lose the guarantee that the values of the corresponding LPs converge to the maximum of the POP (4). Nevertheless, it still provides a valid positivity certificate that we use to upper bound $L ( f _ { d } )$ . In Section 7 we show that in practice it provides upper bounds of good enough quality. If needed, a valid sparsity pattern can be obtained via a chordal completion of the correlative sparsity graph of the POP (Waki et al., 2006).
+
+We now quantify how good this sparsity pattern is. Let $s$ be the size of the largest clique in a sparsity pattern, and let $N _ { i , k }$ be the subset of $N _ { i }$ (defined in Theorem 3) composed of sequences summing up to $k$ . The number of different polynomials for the $k$ -th LP in the hierarchy given by the sparse Krivine’s certificate can be bounded as follows:
+
+$$
+\left| \bigcup _ { i = 1 } ^ { m } N _ { i , k } \right| \leq \sum _ { i = 1 } ^ { m } { \binom { 2 | I _ { i } | + k } { k } } = \mathcal { O } \left( m s ^ { k } \right)
+$$
+
+We immediately see that the dependence on the number of cliques $m$ is really mild (linear) but the size of the cliques as well as the degree of the hierarchy can really impact the size of the optimization problem. Nevertheless, this upper bound can be quite loose; polynomials $h _ { \alpha \beta }$ that depend only on variables in the intersection of two or more cliques are counted more than once.
+
+The number of cliques given in the sparsity pattern induced by $G _ { d }$ is equal to the size of the last layer $m = n _ { d }$ and the size of each clique depends on the particular implementation of the network. We now study different architectures that could arise in practice, and determine the amount of polynomials in their sparse Krivine’s certificate.
+
+Fully connected networks. Even in the case of a network with all nonzero connections, the sparsity pattern induced by $G _ { d }$ decreases the size of the LPs when compared to Krivine’s certificate. In this case the cliques have size $n _ { 1 } + . . . + n _ { d - 1 } + 1$ but they all have the same common intersection equal to all neurons up to the second-to-last hidden layer. A straightforward counting argument shows that the total number of polynomials is $\mathcal { O } ( n ( n _ { 1 } + . . . + n _ { d - 1 } + \bar { 1 } ) ^ { k - 1 } )$ ), improving the upper bound (10).
+
+Unstructured sparsity. In the case of networks obtained by pruning (Hanson & Pratt, 1989) or generated randomly from a distribution over graphs (Xie et al., 2019), the sparsity pattern can be arbitrary. In this case the size of the resulting LPs varies at runtime. Under the layer-wise assumption that any neuron is connected to at most $r$ neurons in the previous layer, the size of the cliques in (9) is bounded as $s = \mathcal { O } ( r ^ { d } )$ . This estimate has an exponential dependency on the depth but ignores that many neurons might share connections to the same inputs in the previous layer, thus being potentially loose. The bound (10) implies that the number of different polynomials is $\mathcal { O } ( n _ { d } r ^ { d k } )$ .
+
+2D Convolutional networks. The sparsity in the weight matrices of convolutional layers has a certain local structure; neurons are connected to contiguous inputs in the previous layer. Adjacent neurons also have many input pixels in common (see Figure 2). Assuming a constant number of channels per layer, the size of the cliques in (9) is $\mathcal { O } ( d ^ { 3 } )$ . Intuitively, such number is proportional to the volume of the pyramid depicted in Figure 2 where each dimension depends linearly on $d$ . Using (10) we get that there are $\mathcal { O } ( \dot { n } _ { d } d ^ { 3 k } )$ different polynomials in the sparse Krivine’s certificate. This is a drastic decrease in complexity when compared to the unstructured sparsity case.
+
+The use of sparsity in polynomial optimization preceeds Theorem 3 (Weisser et al., 2018). First studied in the context of sum-of-squares by Kojima et al. (2005) and further refined in Waki et al. (2006); Lasserre (2006) (and references therein), it has found applications in safety verification (Yang et al., 2016; Zhang et al., 2018), sensor localization Wang et al. (2006), optimal power flow (Ghaddar et al., 2015) and many others. Our work fits precisely into this set of important applications.
+
+# Algorithm 1 LiPopt for ELU activations and sparsity pattern
+
+Input: matrices $\{ W _ { i } \} _ { i = 1 } ^ { d }$ , sparsity pattern $\{ I _ { i } \} _ { i = 1 } ^ { m }$ , hierarchy degree $k$ .   
+1: p ← (2s0 − 1)T W T1 Qd−1i=1 $\triangleright$ compute norm-gradient polynomial   
+2: $x \gets [ s _ { 0 } , \ldots , s _ { d - 1 } ]$   
+3: $b  [ b _ { \gamma } : \gamma \in \mathbb { N } _ { k } ^ { n } ]$ where $\begin{array} { r } { p ( x ) = \sum _ { \gamma \in \mathbb { N } _ { k } ^ { n } } b _ { \gamma } x ^ { \gamma } } \end{array}$ $\triangleright$ compute coefficients of $p$ in basis   
+4: for $i = 1 , \ldots , m$ do   
+5: $N _ { i , k } \gets \{ ( \alpha , \beta ) \in \mathbb { N } _ { k } ^ { 2 n } : \operatorname { s u p p } ( \alpha ) \cap \operatorname { s u p p } ( \beta ) \subseteq I _ { i } \}$   
+6: $\widetilde { N } _ { k } \gets \cup _ { i = 1 } ^ { m } N _ { i , k }$   
+7: $\begin{array} { r } { h  \sum _ { ( \alpha , \beta ) \in \widetilde { N } } c _ { \alpha \beta } h _ { \alpha \beta } } \end{array}$ . compute positivity certificate   
+8: $c  [ c _ { \alpha \beta } : ( \alpha , \beta ) \in \widetilde { N } _ { k } ] ; \ y  [ \lambda , c ]$ $\triangleright$ linear program variables   
+9: $Z \gets [ z _ { \gamma } ] _ { \gamma \in \mathbb { N } _ { k } ^ { n } }$ where $\begin{array} { r } { \lambda - h ( x ) = \sum _ { \gamma \in \mathbb { N } _ { k } ^ { n } } ( z _ { \gamma } ^ { T } y ) x ^ { \gamma } } \end{array}$ $\triangleright$ compute coefficients of $\lambda - h$ in basis   
+return $\operatorname* { m i n } \{ \lambda : b = Z y$ , $y = [ \lambda , c ]$ , $c \geq 0 \}$ $\triangleright$ solve LP
+
+# 5 QCQP REFORMULATION AND SHOR’S SDP RELAXATION
+
+Another way of upper bounding $L ( f _ { d } )$ comes from a further relaxation of (4) to an SDP. We consider the following equivalent formulation where the variables $s _ { i }$ are normalized to lie in the interval $[ - 1 , 1 ]$ , and we rename $t = s _ { 0 }$ :
+
+$$
+L ( f _ { d } ) \leq \operatorname* { m a x } \left\{ \frac { 1 } { 2 ^ { d - 1 } } s _ { 0 } ^ { T } W _ { 1 } ^ { T } \prod _ { i = 1 } ^ { d - 1 } \mathrm { D i a g } ( s _ { i } + 1 ) W _ { i + 1 } ^ { T } : - 1 \leq s _ { i } \leq 1 \right\}
+$$
+
+Any polynomial optimization problem like (11) can be cast as a (possibly non-convex) quadratically constrained quadratic program (QCQP) by introducing new variables and quadratic constraints. This is a well-known procedure described in Park & Boyd (2017, Section 2.1). When $d = 2$ problem (11) is already a QCQP (for the $\ell _ { \infty }$ and $\ell _ { 2 }$ -norm cases) and no modification is necessary.
+
+QCQP reformulation. We illustrate the case $d = 3$ where we have the variables $s _ { 1 } , s _ { 2 }$ corresponding to the first and second hidden layer and a variable $s _ { 0 }$ corresponding to the input. The norm-gradient polynomial in this case is cubic, and it can be rewritten as a quadratic polynomial by introducing new variables corresponding to the product of the first and second hidden layer variables.
+
+More precisely the introduction of a variable $s _ { 1 , 2 }$ with quadratic constraint $s _ { 1 , 2 } = \mathrm { v e c } ( s _ { 1 } s _ { 2 } ^ { T } )$ allows us to write the objective (11) as a quadratic polynomial. The problem then becomes a QCQP with variable $y = [ 1 , s _ { 0 } , s _ { 1 } , s _ { 2 } , s _ { 1 , 2 } ]$ of dimension $1 + n + n _ { 1 } n _ { 2 }$ .
+
+SDP relaxation. Any quadratic objective and constraints can then be relaxed to linear constraints on the positive semidefinite variable $y y ^ { T } = X \succcurlyeq 0$ yielding the so-called Shor’s relaxation of (11) (Park & Boyd, 2017, Section 3.3). When $d = 2$ the resulting SDP corresponds precisely to the one studied in Raghunathan et al. (2018a). This resolves a common misconception (Raghunathan et al., 2018b) that this approach is only limited to networks with one hidden layer.
+
+Note that in our setting we are only interested in the optimal value rather than the optimizers, so there is no need to extract a solution for (11) from that of the SDP relaxation.
+
+Drawback. This approach includes a further relaxation step from (11), thus being fundamentally limited in how tightly it can upper bound the value of $L ( f _ { d } )$ . Moreover when compared to LP solvers, off-the-shelf semidefinite programming solvers are, in general, much more limited in the number of variables they can efficiently handle.
+
+In the case $d = 2$ this relaxation provides a constant factor approximation to the original QCQP (Ye, 1999). Further approximation quality results for such hierarchical optimization approaches to NP-hard problems are out of the scope of this work.
+
+Relation to sum-of-squares. The QCQP approach might appear fundamentaly different to the hierarchical optimization approaches to POPs, like the one described in Section 3. However, it is known that Shor’s SDP relaxation corresponds exactly to the first degree of the SOS hierarchical SDP solution to the QCQP relaxation (Lasserre, 2000). Thus, the approach in section 3 and the one in this section are, in essence, the same; they only differ in the choice of polynomial positivity certificate.
+
+# 6 RELATED WORK
+
+Estimation of $L ( f _ { d } )$ with $\ell _ { 2 }$ -norm is studied by Virmaux & Scaman (2018); Combettes & Pesquet (2019); Fazlyab et al. (2019); Jin & Lavaei (2018). The method SeqLip proposed in Virmaux & Scaman (2018) has the drawback of not providing true upper bounds. It is in fact a heuristic method for solving (4) but which provides no guarantees and thus can not be used for robustness certification. In contrast the LipSDP method of Fazlyab et al. (2019) provides true upper bounds on $L ( f _ { d } )$ and in practice shows superior performance over both SeqLip and CPLip (Combettes & Pesquet, 2019).
+
+Despite the accurate estimation of LipSDP, its formulation is limited to the $\ell _ { 2 }$ -norm. The only estimate available for other $\ell _ { p }$ -norms comes from the equivalence of norms in euclidean spaces. For instance, we can obtain an upper bound for the $\ell _ { \infty }$ -norm after multiplying the $\ell _ { 2 }$ Lipschitz constant upper bound by the square root of the input dimension. The resulting bound can be rather loose and our experiments in section 7 confirm the issue. In contrast, our proposed approach LiPopt can acommodate any norm whose unit ball can be described via polynomial inequalities.
+
+Let us point to one key advantage of LiPopt, compared to LipSDP (Jin & Lavaei, 2018; Fazlyab et al., 2019). In the context of robustness certification we are given a sample $x ^ { \sharp }$ and a ball of radius $\epsilon$ around it. Computing an upper bound on the local Lipschitz constant in this subset, rather than a global one, can provide a larger region of certified robustness. Taking into account the restricted domain we can refine the bounds in our POP (see remark in section 1). This potentially yields a tighter estimate of the local Lipschitz constant. On the other hand, it is not clear how to include such additional information in LipSDP, which only computes one global bound on the Lipschitz constant for the unconstrained network.
+
+Raghunathan et al. (2018a) find an upper bound for $L ( f _ { d } )$ with $\ell _ { \infty }$ metric starting from problem (4) but only in the context of one-hidden-layer networks $\ Q = 2 ,$ ). To compute such bound they use its corresponding Shor’s relaxation and obtain as a byproduct a differentiable regularizer for training networks. They claim such approach is limited to the setting $d = 2$ but, as we remark in section 5, it is just a particular instance of the SDP relaxation method for QCQPs arising from a polynomial optimization problem. We find that this method fits into the LiPopt framework, using SOS certificates instead of Krivine’s. We expect that the SDP-based bounds described in 5 can also be used as regularizers promoting robustness.
+
+Weng et al. (2018) provide an upper bound on the local Lipschitz constant for networks based on a sequence of ad-hoc bounding arguments, which are particular to the choice of ReLU activation function. In contrast, our approach applies in general to activations whose derivative is bounded.
+
+# 7 EXPERIMENTS
+
+We consider the following estimators of $L ( f _ { d } )$ with respect to the $\ell _ { \infty }$ norm:
+
+<table><tr><td rowspan=1 colspan=1>Name</td><td rowspan=1 colspan=1>Description</td></tr><tr><td rowspan=1 colspan=1>SDP</td><td rowspan=1 colspan=1>Upper bound arising from the solution of the SDP relaxation described in Sec-tion 5</td></tr><tr><td rowspan=1 colspan=1>LipOpt-k</td><td rowspan=1 colspan=1>Upper bound arising from the k-th degree of the LP hierarchy (6) based on thesparse Krivine Positivstellenstatz.</td></tr><tr><td rowspan=1 colspan=1>Lip-SDP</td><td rowspan=1 colspan=1>Upper bound from Fazlyab et al. (2019) multiplied √d where d is the inputdimension of the network.</td></tr><tr><td rowspan=1 colspan=1>UBP</td><td rowspan=1 colspan=1>Upper bound determined by the product of the layer-wise Lipschitz constantswith loometric</td></tr><tr><td rowspan=1 colspan=1>LBS</td><td rowspan=1 colspan=1>Lower bound obtained by sampling 5oooO random points around zero, andevaluating the dual norm of the gradient</td></tr></table>
+
+# 7.1 EXPERIMENTS ON RANDOM NETWORKS
+
+We compare the bounds obtained by the algorithms described above on networks with random weights and either one or two hidden layers. We define the sparsity level of a network as the maximum number of neurons any neuron in one layer is connected to in the next layer. For example, the network represented on Figure 1 has sparsity 2. The non-zero weights of network’s $i$ -th layer are sampled uniformly in $[ - \frac { \breve { 1 } } { \sqrt { n _ { i } } } , \frac { 1 } { \sqrt { n _ { i } } } ]$ where $n _ { i }$ is the number of neurons in layer $i$ .
+
+For different configurations of width and sparsity, we generate 10 random networks and average the obtained Lipschitz bounds. For better comparison, we plot the relative error. Since we do not know the true Lipschitz constant, we cannot compute the true relative error. Instead, we take as reference the lower bound given by LBS. Figures 3 and 5 show the relative error, i.e., $( \hat { L } - L _ { L B S } ) / L _ { L B S }$ where $L _ { L B S }$ is the lower bound computed by LBS and $\hat { L }$ is the estimated upper bound. Figures 9 and 10 in Appendix C we show the values of the computed Lipschitz bounds for 1 and 2 hidden layers respectively.
+
+When the chosen degree for LiPopt-k is the smallest as possible, i.e., equal to the depth of the network, we observe that the method is already competitive with the SDP method, especially in the case of 2 hidden layers. When we increment the degree by 1, LiPopt-k becomes uniformly better than SDP over all tested configurations. We remark that the upper bounds given by UBP are too large to be shown in the plots. Similarly, for the 1-hidden layer networks, the bounds from LipSDP are too large to be plotted.
+
+Finally, we measured the computation time of the different methods on each tested network (Figures 4 and 6). We observe that the computation time for LiPopt-k heavily depends on the network sparsity, which reflects the fact that such structure is exploited in the algorithm. In contrast, the time required for SDP does not depend on the sparsity, but only on the size of the network. Therefore as the network size grows (with fixed sparsity level), LipOpt-k obtains a better upper bound and runs faster. Also, with our method, we see that it is possible to increase the computation power in order to compute tighter bounds when required, making it more flexible than SDP in terms of computation/accuracy tradeoff. LiPopt uses the Gurobi LP solver, while SDP uses Mosek. All methods run on a single machine with Core i7 2.8Ghz quad-core processor and 16Gb of RAM.
+
+![](images/36715696c6d13101074bebdd53e4699329e7143885a21b2eaae6a91eea796e9d.jpg)  
+Figure 3: Lipschitz approximated relative error for 1-hidden layer networks
+
+![](images/16f4460aa96107ed8b842356f329b5f9c62f18f106042c719ca032bde18b336b.jpg)  
+Figure 4: Computation times for 1-hidden layer networks (seconds)
+
+![](images/688cbbb935006042a5b738de27979cf8fb8ddd23c626da768e5bb13bf7dbf66b.jpg)  
+Figure 5: Lipschitz approximated relative error for 2-hidden layer networks
+
+![](images/2913548161f337fdbd03d9ad1bbad83e6f237e8215410cc7e959db088133e3f3.jpg)  
+Figure 6: Computation times for 2-hidden layer networks (seconds)
+
+# 7.2 EXPERIMENTS ON TRAINED NETWORKS
+
+Similarly, we compare these methods on networks trained on MNIST. The architecture we use is a fully connected network with two hidden layers with 300 and 100 neurons respectively, and with one-hot output of size 10. Since the output is multi-dimensional, we restrict the network to a single output, and estimate the Lipschitz constant with respect to label 8.
+
+Moreover, in order to improve the scalability of our method, we train the network using the pruning strategy described in Han et al. $( 2 0 1 5 ) ^ { 2 }$ . After training the full network using a standard technique, the weights of smallest magnitude are set to zero. Then, the network is trained for additional iterations, only updating the nonzero parameters. Doing so, we were able to remove $9 5 \%$ of the weights, while preserving the same test accuracy. We recorded the Lipschitz bounds for various methods in Table 7.2. We observe clear improvement of the Lipschitz bound obtained from LiPopt-k compared to SDP method, even when using $k = 3$ . Also note that the input dimension is too large for the method Lip-SDP to provide competitive bound, so we do not provide the obtained bound for this method.
+
+<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>LBS</td><td rowspan=1 colspan=1>LiPopt-4</td><td rowspan=1 colspan=1>LiPopt-3</td><td rowspan=1 colspan=1>SDP</td><td rowspan=1 colspan=1>UBP</td></tr><tr><td rowspan=1 colspan=1>Lipschitz bound</td><td rowspan=1 colspan=1>84.2</td><td rowspan=1 colspan=1>88.3</td><td rowspan=1 colspan=1>94.6</td><td rowspan=1 colspan=1>98.8</td><td rowspan=1 colspan=1>691.5</td></tr></table>
+
+# 7.3 ESTIMATING LOCAL LIPSCHITZ CONSTANTS WITH LIPOPT
+
+In the of section 7.1, we study the improvement on the upper bound obtained by LiPopt, when we incorporate tighter upper and lower bounds on the variables $s _ { i }$ of the polynomial optimization problem (4). Such bounds arise from the limited range that the pre-activation values of the network can take, when the input is limited to an $\ell _ { \infty }$ -norm ball of radius $\epsilon$ centered at an arbitrary point $x _ { 0 }$ .
+
+The algorithm that computes upper and lower bounds on the pre-activation values is fast (it has the same complexity as a forward pass) and is described, for example, in Wong & Kolter (2018). The variables $s _ { i }$ correspond to the value of the derivative of the activation function. For activations like ELU or ReLU, their derivative is monotonically increasing, so we need only evaluate it at the upper and lower bounds of the pre-activation values to obtain corresponding bounds for the variables $s _ { i }$ .
+
+We plot the local upper bounds obtained by LiPopt-3 for increasing values of the radius $\epsilon$ , the bound for the global constant (given by LiPopt-3) and the lower bound on the local Lipschitz constant obtained by sampling in the $\epsilon$ -neighborhood (LBS). We sample 15 random networks and plot the average values obtained. We observe clear gap between both estimates, which shows that larger certified balls could be obtained with such method in the robustness certification applications.
+
+![](images/caca3de17318ea9710940bfd4d6d9c624bdb96ef7815b200478040db061a5551.jpg)  
+Figure 7: Global vs local Lipschitz constant bounds for 1-hidden layer networks
+
+![](images/adac380da60ee5e5deb213f94cacd68bbe4c0a5ffac2336cfd61a636727ca433.jpg)  
+Figure 8: Global vs local Lipschitz constant bounds for 2-hidden layer networks
+
+# 8 CONCLUSION AND FUTURE WORK
+
+In this work, we have introduced a general approach for computing an upper bound on the Lipschitz constant of neural networks. This approach is based on polynomial positivity certificates and generalizes some existing methods available in the literature. We have empirically demonstrated that it can tightly upper bound such constant. The resulting optimization problems are computationally expensive but the sparsity of the network can reduce this burden.
+
+In order to further scale such methods to larger and deeper networks, we are interested in several possible directions: $( i )$ divide-and-conquer approaches splitting the computation on sub-networks in the same spirit of Fazlyab et al. (2019), $( i i )$ exploiting parallel optimization algorithms leveraging the structure of the polynomials, $( i i i )$ custom optimization algorithms with low-memory costs such as Frank-wolfe-type methods for SDP (Yurtsever et al., 2019) as well as stochastic handling of constraints (Fercoq et al., 2019) and $( i v )$ , exploting the symmetries in the polynomial that arise from weight sharing in typical network architectures to further reduce the size of the problems.
+
+# ACKNOWLEDGMENTS
+
+This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement 725594 - time-data) and from the Swiss National Science Foundation (SNSF) under grant number 200021 178865. FL is supported through a PhD fellowship of the Swiss Data Science Center, a joint venture between EPFL and ETH Zurich. VC acknowledges the 2019 Google Faculty Research Award.
+
+REFERENCES   
+A. Ahmadi and A. Majumdar. Dsos and sdsos optimization: More tractable alternatives to sum of squares and semidefinite optimization. SIAM Journal on Applied Algebra and Geometry, 3(2):193–230, 2019. doi: 10.1137/18M118935X. URL https://doi.org/10.1137/ 18M118935X.   
+Cem Anil, James Lucas, and Roger Grosse. Sorting out Lipschitz function approximation. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 291–301, Long Beach, California, USA, 09–15 Jun 2019. PMLR.   
+Martin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 214–223, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR.   
+Peter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. In Advances in Neural Information Processing Systems 30, pp. 6240–6249. Curran Associates, Inc., 2017.   
+Felix Berkenkamp, Matteo Turchetta, Angela Schoellig, and Andreas Krause. Safe model-based reinforcement learning with stability guarantees. In Advances in Neural Information Processing Systems 30, pp. 908–918. Curran Associates, Inc., 2017.   
+Moustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 854–863, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR.   
+Djork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and Accurate Deep Network ´ Learning by Exponential Linear Units (ELUs). arXiv e-prints, art. arXiv:1511.07289, Nov 2015.   
+Patrick L. Combettes and Jean-Christophe Pesquet. Lipschitz Certificates for Neural Network Structures Driven by Averaged Activation Operators. arXiv e-prints, art. arXiv:1903.01014, Mar 2019.   
+Mahyar Fazlyab, Alexander Robey, Hamed Hassani, Manfred Morari, and George J. Pappas. Efficient and Accurate Estimation of Lipschitz Constants for Deep Neural Networks. arXiv e-prints, art. arXiv:1906.04893, Jun 2019.   
+Olivier Fercoq, Ahmet Alacaoglu, Ion Necoara, and Volkan Cevher. Almost surely constrained convex optimization. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 1910–1919, Long Beach, California, USA, 09–15 Jun 2019. PMLR.   
+Jonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019.   
+Bissan Ghaddar, Jakub Marecek, and Martin Mevissen. Optimal power flow as a polynomial optimization problem. IEEE Transactions on Power Systems, 31(1):539–546, 2015.   
+Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems 30, pp. 5767–5777. Curran Associates, Inc., 2017.   
+Song Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.   
+David Handelman. Representing polynomials by positive linear functions on compact convex polyhedra. Pacific J. Math., 132(1):35–62, 1988. URL https://projecteuclid.org: 443/euclid.pjm/1102689794.   
+Stephen Jose Hanson and Lorien Y. Pratt. Comparing biases for minimal network construction with back-propagation. In Advances in Neural Information Processing Systems 1, pp. 177–185. Morgan-Kaufmann, 1989.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition, pp. 770–778, 06 2016. doi: 10.1109/CVPR.2016.90.
+
+Todd Huster, Cho-Yu Jason Chiang, and Ritu Chadha. Limitations of the Lipschitz constant as a defense against adversarial examples. arXiv e-prints, art. arXiv:1807.09705, Jul 2018.
+
+Ming Jin and Javad Lavaei. Stability-certified reinforcement learning: A control-theoretic perspective. arXiv e-prints, art. arXiv:1810.11505, Oct 2018.
+
+Masakazu Kojima, Sunyoung Kim, and Hayato Waki. Sparsity in sums of squares of polynomials. Mathematical Programming, 103(1):45–62, May 2005. ISSN 1436-4646. doi: 10.1007/s10107-004-0554-3.
+
+Jean-Louis Krivine. Anneaux preordonn ´ es. ´ Journal d’analyse mathematique ´ , 12:p. 307–326, 1964.
+
+J. B. Lasserre. Convergent lmi relaxations for nonconvex quadratic programs. In Proceedings of the 39th IEEE Conference on Decision and Control (Cat. No.00CH37187), volume 5, pp. 5041–5046 vol.5, Dec 2000. doi: 10.1109/CDC.2001.914738.
+
+Jean B Lasserre. Convergent sdp-relaxations in polynomial optimization with sparsity. SIAM Journal on Optimization, 17(3):822–843, 2006.
+
+Jean Bernard Lasserre. An Introduction to Polynomial and Semi-Algebraic Optimization. Cambridge Texts in Applied Mathematics. Cambridge University Press, 2015. doi: 10.1017/ CBO9781107447226.
+
+Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, Nov 1998. doi: 10.1109/5.726791.
+
+Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In International Conference on Learning Representations, 2018.
+
+Jaehyun Park and Stephen Boyd. General heuristics for nonconvex quadratically constrained quadratic programming. arXiv preprint arXiv:1703.07870, 2017.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. In International Conference on Learning Representations, 2018a.
+
+Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Advances in Neural Information Processing Systems, pp. 10877–10887, 2018b.
+
+Gilbert Stengle. A nullstellensatz and a positivstellensatz in semialgebraic geometry. Mathematische Annalen, 207(2):87–97, Jun 1974. ISSN 1432-1807. doi: 10.1007/BF01362149.
+
+Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, 2014.
+
+Aladin Virmaux and Kevin Scaman. Lipschitz regularity of deep neural networks: analysis and efficient estimation. In Advances in Neural Information Processing Systems 31, pp. 3835–3844. Curran Associates, Inc., 2018.
+
+H. Waki, S. Kim, M. Kojima, and M. Muramatsu. Sums of squares and semidefinite program relaxations for polynomial optimization problems with structured sparsity. SIAM Journal on Optimization, 17(1):218–242, 2006. doi: 10.1137/050623802.
+
+Zizhuo Wang, Song Zheng, Stephen Boyd, and Yinyu Ye. Further relaxations of the sdp approach to sensor network localization. Tech. Rep., 2006.
+
+Tillmann Weisser, Jean B Lasserre, and Kim-Chuan Toh. Sparse-bsos: a bounded degree sos hierarchy for large scale polynomial optimization with sparsity. Mathematical Programming Computation, 10(1):1–32, 2018.
+
+Lily Weng, Huan Zhang, Hongge Chen, Zhao Song, Cho-Jui Hsieh, Luca Daniel, Duane Boning, and Inderjit Dhillon. Towards fast computation of certified robustness for ReLU networks. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 5276–5285, Stockholmsmassan, Stockholm Sweden, 10–15 ¨ Jul 2018. PMLR.
+
+Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 5286–5295, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018. PMLR.
+
+Eric Wong, Frank Schmidt, and Zico Kolter. Wasserstein adversarial examples via projected Sinkhorn iterations. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 6808–6817, Long Beach, California, USA, 09–15 Jun 2019. PMLR.
+
+Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring Randomly Wired Neural Networks for Image Recognition. International Conference on Computer Vision, Apr 2019.
+
+Zhengfeng Yang, Chao Huang, Xin Chen, Wang Lin, and Zhiming Liu. A linear programming relaxation based approach for generating barrier certificates of hybrid systems. In John Fitzgerald, Constance Heitmeyer, Stefania Gnesi, and Anna Philippou (eds.), FM 2016: Formal Methods, pp. 721–738, Cham, 2016. Springer International Publishing. ISBN 978-3-319-48989-6.
+
+Yinyu Ye. Approximating quadratic programming with bound and quadratic constraints. Mathematical Programming, 84(2):219–226, Feb 1999. ISSN 1436-4646. doi: 10.1007/s10107980012a.
+
+Alp Yurtsever, Olivier Fercoq, and Volkan Cevher. A conditional-gradient-based augmented lagrangian framework. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 7272–7281, Long Beach, California, USA, 09–15 Jun 2019. PMLR.
+
+Y. Zhang, Z. Yang, W. Lin, H. Zhu, X. Chen, and X. Li. Safety verification of nonlinear hybrid systems based on bilinear programming. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 37(11):2768–2778, Nov 2018. doi: 10.1109/TCAD.2018.2858383.
+
+# A PROOF OF THEOREM 1
+
+Theorem. Let $f$ be a differentiable and Lipschitz continuous function on an open, convex subset $\mathcal { X }$ of a euclidean space. Let $\| \cdot \|$ be the dual norm. The Lipschitz constant of $f$ is given by
+
+$$
+L ( f ) = \operatorname* { s u p } _ { x \in \mathcal { X } } \| \nabla f ( x ) \| _ { * }
+$$
+
+Proof. First we show that $L ( f ) \leq \operatorname* { s u p } _ { x \in \mathcal { X } } \left\| \nabla f ( x ) \right\| _ { * }$ .
+
+$$
+\begin{array} { r l } { | f ( y ) - f ( x ) | = \displaystyle \left. \int _ { 0 } ^ { 1 } \nabla f ( ( 1 - t ) x + t y ) ^ { T } ( y - x ) d t \right. } & { } \\ { \displaystyle } & { \le \displaystyle \int _ { 0 } ^ { 1 } \left. \nabla f ( ( 1 - t ) x + t y ) ^ { T } ( y - x ) \right. d t } \\ { \displaystyle } & { \le \displaystyle \int _ { 0 } ^ { 1 } \| \nabla f ( ( 1 - t ) x + t y ) \| _ { * } d t \| y - x \| } \\ { \displaystyle } & { \le \operatorname* { s u p } _ { x \in \mathcal { X } } \| \nabla f ( x ) \| _ { * } \| y - x \| } \end{array}
+$$
+
+were we have used the convexity of $\mathcal { X }$ .
+
+Now we show the reverse inequality $L ( f ) \geq \operatorname* { s u p } _ { x \in \mathcal { X } } \| \nabla f ( x ) \| _ { * }$ . To this end, we show that for any positive $\epsilon$ , we have that $L ( f ) \geq \operatorname* { s u p } _ { x \in \mathcal { X } } \| \nabla f ( x ) \| _ { * } ^ { - } - \epsilon$ .
+
+Let $z \in \mathcal { X }$ be such that $\begin{array} { r } { \| \nabla f ( z ) \| _ { * } \geq \operatorname* { s u p } _ { x \in \mathcal { X } } \| \nabla f ( x ) \| _ { * } - \epsilon } \end{array}$ . Because $\mathcal { X }$ is open, there exists a sequence $\{ h _ { k } \} _ { k = 1 } ^ { \infty }$ with the following properties:
+
+1. $\langle h _ { k } , \nabla f ( z ) \rangle = \| h _ { k } \| \| \nabla f ( z ) \| _ { * }$   
+2. $z + h _ { k } \in \mathcal { X }$   
+3. $\scriptstyle \operatorname* { l i m } _ { k \to \infty } h _ { k } = 0$ .
+
+By definition of the gradient, there exists a function $\delta$ such that $\begin{array} { r } { \operatorname* { l i m } _ { h  0 } \delta ( h ) = 0 } \end{array}$ and the following holds:
+
+$$
+f ( z + h ) = f ( z ) + \langle h , \nabla f ( z ) \rangle + \delta ( h ) \| h \|
+$$
+
+For our previously defined iterates $h _ { k }$ we then have
+
+$$
+\Rightarrow | f ( z + h _ { k } ) - f ( z ) | = | \| h _ { k } \| \| \nabla f ( z ) \| _ { * } + \delta ( h _ { k } ) \| h _ { k } \| |
+$$
+
+Dividing both sides by $\| h _ { k } \|$ and using the definition of $L ( f )$ we finally get
+
+$$
+\begin{array} { r l } & { \Rightarrow L ( f ) \geq \left| \frac { f ( z + h _ { k } ) - f ( z ) } { \| h _ { k } \| } \right| = \| \| \nabla f ( z ) \| _ { * } + \delta ( h _ { k } ) \| } \\ & { \Rightarrow L ( f ) \geq \underset { k \to \infty } { \operatorname* { l i m } } \left| \| f ( z ) \| _ { * } + \delta ( h _ { k } ) \right| = \| \nabla f ( z ) \| _ { * } } \\ & { \Rightarrow L ( f ) \geq \underset { x \in \mathcal { X } } { \operatorname* { s u p } } \| \nabla f ( x ) \| _ { * } - \epsilon } \end{array}
+$$
+
+# B PROOF OF PROPOSITION 1
+
+Proposition. Let $f _ { d }$ be a dense network (all weights are nonzero). The following sets, indexed by $i = 1 , \ldots , n _ { d } ,$ form a valid sparsity pattern for the norm-gradient polynomial of the network $f _ { d }$ :
+
+$$
+I _ { i } : = \left\{ s _ { ( d - 1 , i ) } \right\} \cup \left\{ s _ { ( j , k ) } : t h e r e \ e x i s t s a \ d i r e c t e d p a t h f r o m \ s _ { ( j , k ) } \ t o \ s _ { ( d - 1 , i ) } \ i n \ G _ { d } \right\}
+$$
+
+Proof. First we show that $\cup _ { i = 1 } ^ { m } I _ { i } = I$ . This comes from the fact that any neuron in the network is connected to at least one neuron in the last layer. Otherwise such neuron could be removed from the network altogether.
+
+Now we show the second property of a valid sparsity pattern. Note that the norm-gradient polynomial is composed of monomials corresponding to the product of variables in a path from input to a final neuron. This imples that if we let $p _ { i }$ be the sum of all the terms that involve the neuron $s _ { ( d - 1 , i ) }$ we have that $p = \sum _ { i } p _ { i }$ , and $p _ { i }$ only depends on the variables in $I _ { i }$ .
+
+We now show the last property of the valid sparsity pattern. This is the only part where we use that the network is dense. For any network architecture the first two conditions hold. We will use the fact that the maximal cliques of a chordal graph form a valid sparsity pattern (see for example Lasserre (2006)).
+
+Because the network is dense, we see that the clique $I _ { i }$ is composed of the neuron in the last layer $s _ { ( d - 1 , i ) }$ and all neurons in the previous layers. Now consider the extension of the computational graph $\hat { G } _ { d } = ( V , \hat { E } )$ where
+
+$$
+\hat { E } = E \cup \{ ( s _ { j , k } , s _ { l , m } ) : j , l \leq d - 2 ) \}
+$$
+
+which consists of adding all the edges between the neurons that are not in the last layer. We show that this graph is chordal. Let $( a _ { 1 } , \ldots , a _ { r } , a _ { 1 } )$ be a cycle of length at least 4 $( r \geq 4 )$ ). notice that because neurons in the last layer are not connected between them in $\hat { G }$ , no two consecutive neurons in this cycle belong to the last layer. This implies that in the subsequence $( a _ { 1 } , a _ { 2 } , a _ { 3 } , a _ { 4 } , a _ { 5 } )$ at most three belong to the last layer. A simple analysis of all cases implies that it contains at least two nonconsecutive neurons not in the last layer. Neurons not in the last layer are always connected in $\hat { G }$ . This constitutes a chord. This shows that $\hat { G } _ { d }$ is a chordal graph. Its maximal cliques correspond exactly to the sets in proposition.
+
+![](images/c4d3bde944b1201dbb14a1b15dbe0955ab341b628a0782d8b01936caadfeaf19.jpg)  
+Figure 9: Lipschitz bound comparison for 1-hidden layer networks
+
+![](images/5b9afc5939934f50f5c505c382a417332da65ece6fd0ac90a05e2e208e5c12a0.jpg)  
+Figure 10: Lipschitz bound comparison for 2-hidden layer networks

parse/train/rJe4_xSFDB/rJe4_xSFDB_content_list.json

@@ -0,0 +1,2027 @@
+[
+    {
+        "type": "text",
+        "text": "LIPSCHITZ CONSTANT ESTIMATION OF NEURAL NETWORKS VIA SPARSE POLYNOMIAL OPTIMIZATION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            99,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Fabian Latorre, Paul Rolland and Volkan Cevher EPFL, Switzerland firstname.lastname@epfl.ch ",
+        "bbox": [
+            183,
+            169,
+            527,
+            212
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            248,
+            544,
+            263
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We introduce LiPopt, a polynomial optimization framework for computing increasingly tighter upper bounds on the Lipschitz constant of neural networks. The underlying optimization problems boil down to either linear (LP) or semidefinite (SDP) programming. We show how to use the sparse connectivity of a network, to significantly reduce the complexity of computation. This is specially useful for convolutional as well as pruned neural networks. We conduct experiments on networks with random weights as well as networks trained on MNIST, showing that in the particular case of the $\\ell _ { \\infty }$ -Lipschitz constant, our approach yields superior estimates, compared to baselines available in the literature. ",
+        "bbox": [
+            232,
+            280,
+            764,
+            406
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            433,
+            336,
+            449
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "We consider a neural network $f _ { d }$ defined by the recursion: ",
+        "bbox": [
+            176,
+            465,
+            555,
+            479
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ded54dbcbd18d154034b9d67f56076860b19495ceaece4b0a3a42c57579b382e.jpg",
+        "text": "$$\nf _ { 1 } ( x ) : = W _ { 1 } x \\qquad f _ { i } ( x ) : = W _ { i } \\sigma ( f _ { i - 1 } ( x ) ) , \\quad i = 2 , \\ldots , d\n$$",
+        "text_format": "latex",
+        "bbox": [
+            302,
+            487,
+            696,
+            505
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "for an integer $d$ larger than 1, matrices $\\{ W _ { i } \\} _ { i = 1 } ^ { d }$ of appropriate dimensions and an activation function $\\sigma$ , understood to be applied element-wise. We refer to $d$ as the depth, and we focus on the case where $f _ { d }$ has a single real value as output. ",
+        "bbox": [
+            174,
+            511,
+            825,
+            554
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In this work, we address the problem of estimating the Lipschitz constant of the network $f _ { d }$ . A function $f$ is Lipschitz continuous with respect to a norm $\\left\\| \\cdot \\right\\|$ if there exists a constant $L$ such that for all $x , y$ we have $| f ( x ) - f ( y ) | \\leq L \\| x - y \\|$ . The minimum over all such values satisfying this condition is called the Lipschitz constant of $f$ and is denoted by $L ( f )$ . ",
+        "bbox": [
+            174,
+            560,
+            825,
+            617
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "The Lipschitz constant of a neural network is of major importance in many successful applications of deep learning. In the context of supervised learning, Bartlett et al. (2017) show how it directly correlates with the generalization ability of neural network classifiers, suggesting it as model complexity measure. It also provides a measure of robustness against adversarial perturbations (Szegedy et al., 2014) and can be used to improve such metric (Cisse et al., 2017). Moreover, an upper bound on $L ( f _ { d } )$ provides a certificate of robust classification around data points (Weng et al., 2018). ",
+        "bbox": [
+            173,
+            623,
+            823,
+            708
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Another example is the discriminator network of the Wasserstein GAN (Arjovsky et al., 2017), whose Lipschitz constant is constrained to be at most 1. To handle this constraint, researchers have proposed different methods like heuristic penalties (Gulrajani et al., 2017), upper bounds (Miyato et al., 2018), choice of activation function (Anil et al., 2019), among many others. This line of work has shown that accurate estimation of such constant is key to generating high quality images. ",
+        "bbox": [
+            174,
+            713,
+            823,
+            785
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Lower bounds or heuristic estimates of $L ( f _ { d } )$ can be used to provide a general sense of how robust a network is, but fail to provide true certificates of robustness to input perturbations. Such certificates require true upper bounds, and are paramount when deploying safety-critical deep reinforcement learning applications (Berkenkamp et al., 2017; Jin & Lavaei, 2018). The trivial upper bound given by the product of layer-wise Lipschitz constants is easy to compute but rather loose and overly pessimistic, providing poor insight into the true robustness of a network (Huster et al., 2018). ",
+        "bbox": [
+            173,
+            790,
+            825,
+            875
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Indeed, there is a growing need for methods that provide tighter upper bounds on $L ( f _ { d } )$ , even at the expense of increased complexity. For example Raghunathan et al. (2018a); Jin & Lavaei (2018); Fazlyab et al. (2019) derive upper bounds based on semidefinite programming $( S D P )$ . While expensive to compute, these type of certificates are in practice surprisingly tight. Our work belongs in this vein of research, and aims to overcome some limitations in the current state-of-the-art. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our Contributions. ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            138,
+            308,
+            154
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": ". We present LiPopt, a general approach for upper bounding the Lipschitz constant of a neural network based on a relaxation to a polynomial optimization problem (POP) (Lasserre, 2015). This approach requires only that the unit ball be described with polynomial inequalities, which covers the common $\\ell _ { 2 ^ { - } }$ and $\\ell _ { \\infty }$ -norms. . Based on a theorem due to Weisser et al. (2018), we exploit the sparse connectivity of neural network architectures to derive a sequence of linear programs (LPs) of considerably smaller size than their vanilla counterparts. We provide an asymptotic analysis of the size of such programs, in terms of the number of neurons, depth and sparsity of the network. . Focusing on the $\\ell _ { \\infty }$ -norm, we experiment on networks with random weights and networks trained on MNIST (Lecun et al., 1998). We evaluate different configurations of depth, width and sparsity and we show that the proposed sequence of LPs can provide tighter upper bounds on $\\dot { L } ( f _ { d } )$ compared to other baselines available in the literature. ",
+        "bbox": [
+            214,
+            165,
+            825,
+            342
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Notation. We denote by $n _ { i }$ the number of columns of the matrix $W _ { i }$ in the definition (1) of the network. This corresponds to the size of the $i$ -th layer, where we identify the input as the first layer. We let $n = n _ { 1 } + . . . + n _ { d }$ be the total number of neurons in the network. For a vector $x$ , $\\operatorname { D i a g } ( x )$ denotes the square matrix with $x$ in its diagonal and zeros everywhere else. For an array $X$ , $\\operatorname { v e c } ( X )$ is the flattened array. The support of a sequence $\\operatorname { s u p p } ( \\alpha )$ is defined as the set of indices $j$ such that $\\alpha _ { j }$ is nonnote by o. For the m $x = [ x _ { 1 } , \\ldots , x _ { n } ]$ a sequence of nonnegative integers . The set of nonnegative integers is $\\gamma = [ \\gamma _ { 1 } , \\dotsc , \\gamma _ { n } ]$ we $x ^ { \\gamma }$ $x _ { 1 } ^ { \\gamma _ { 1 } } x _ { 2 } ^ { \\gamma _ { 2 } } \\ldots x _ { n } ^ { \\gamma _ { n } }$ $\\mathbb { N }$ ",
+        "bbox": [
+            173,
+            353,
+            825,
+            453
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Remark. The definition of network (1) covers typical architectures composed of dense and convolutional layers. In general, our proposed approach can be readily extended with minor modifications to any directed acyclic computation graph e.g., residual network architectures (He et al., 2016). ",
+        "bbox": [
+            174,
+            458,
+            825,
+            501
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 POLYNOMIAL OPTIMIZATION FORMULATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            521,
+            575,
+            536
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "In this section we derive an upper bound on $L ( f _ { d } )$ given by the value of a POP, i.e. the minimum value of a polynomial subject to polynomial inequalities. Our starting point is the following theorem, which casts $\\dot { L } ( f )$ as an optimization problem: ",
+        "bbox": [
+            174,
+            551,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Theorem 1. Let $f$ be a differentiable and Lipschitz continuous function on an open, convex subset $\\mathcal { X }$ of an euclidean space. Let $\\left\\| \\cdot \\right\\| _ { * }$ be the dual norm. The Lipschitz constant of $f$ is given by ",
+        "bbox": [
+            173,
+            598,
+            823,
+            627
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/60509a44624d170b551ac8124e22f37454b86cf5c67ce09ac35dcfaaec65ac75.jpg",
+        "text": "$$\nL ( f ) = \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\nabla f ( x ) \\| _ { * }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            633,
+            576,
+            660
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For completeness, we provide a proof in appendix A. In our setting, we assume that the activation function $\\sigma$ is Lipschitz continuous and differentiable. In this case, the assumptions of Theorem 1 are fulfilled because $f _ { d }$ is a composition of activations and linear transformations. The differentiability assumption rules out the common ReLU activation $\\sigma ( x ) = \\operatorname* { m a x } \\{ 0 , x \\}$ , but allows many others such as the exponential linear unit (ELU) (Clevert et al., 2015) or the softplus. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            743
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Using the chain rule, the compositional structure of $f _ { d }$ yields the following formula for its gradient: ",
+        "bbox": [
+            174,
+            750,
+            821,
+            765
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/8c315039031f15ba726b0bd654a23f3b741bc72bb3b9c78c76e7d7e1c56f75ac.jpg",
+        "text": "$$\n\\nabla f _ { d } ( x ) = W _ { 1 } ^ { T } \\prod _ { i = 1 } ^ { d - 1 } \\operatorname { D i a g } ( \\sigma ^ { \\prime } ( f _ { i } ( x ) ) ) W _ { i + 1 } ^ { T }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            359,
+            772,
+            638,
+            816
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "For every $i = 1 , \\ldots , d - 1$ we introduce a variable $s _ { i } = \\sigma ^ { \\prime } ( f _ { i } ( x ) )$ corresponding to the derivative of $\\sigma$ at the $i$ -th hidden layer of the network. For activation functions like ELU or softplus, their derivative is bounded between 0 and 1, which implies that $0 \\leq s _ { i } \\leq 1$ . This bound together with the definition of the dual norm $\\| x \\| _ { * } : = \\operatorname* { s u p } _ { \\| t \\| \\leq 1 } t ^ { T } \\bar { x }$ implies the following upper bound of $L ( f _ { d } )$ : ",
+        "bbox": [
+            174,
+            819,
+            825,
+            878
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/62b8f435440d06d49028a508591599cb300936b48d32010bafd9b338fb37e55a.jpg",
+        "text": "$$\nL ( f _ { d } ) \\leq \\operatorname* { m a x } \\left\\{ t ^ { T } W _ { 1 } ^ { T } \\prod _ { i = 1 } ^ { d - 1 } \\operatorname { D i a g } ( s _ { i } ) W _ { i + 1 } ^ { T } : 0 \\leq s _ { i } \\leq 1 , \\| t \\| \\leq 1 \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            279,
+            885,
+            718,
+            928
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We will refer to the polynomial objective of this problem as the norm-gradient polynomial of the network $f _ { d }$ , a central object of study in this work. ",
+        "bbox": [
+            173,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For some frequently used $\\ell _ { p }$ -norms, the constraint $\\| t \\| _ { p } \\leq 1$ can be written with polynomial inequalities. In the rest of this work, we use exclusively the $\\ell _ { \\infty }$ -norm for which $\\| t \\| _ { \\infty } \\dot { \\leq } 1$ is equivalent to the polynomial inequalities $- 1 \\leq t _ { i } \\leq 1$ , for $i = 1 , \\ldots , n _ { 1 }$ . However, note that when $p \\geq 2$ is a positive even integer, $\\| t \\| _ { p } \\leq 1$ is equivalent to a single polynomial inequality $\\| t \\| _ { p } ^ { p } \\leq 1$ , and our proposed approach can be adapted with minimal modifications. ",
+        "bbox": [
+            173,
+            138,
+            825,
+            208
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In such cases, the optimization problem in the right-hand side of (4) is a POP. Optimization of polynomials is a NP-hard problem and we do not expect to have efficient algorithms for solving (4) in this general form. In the next sections we describe LiPopt: a systematic way of obtaining an upper bound on $L ( f _ { d } )$ via tractable approximation methods of the POP (4). ",
+        "bbox": [
+            173,
+            215,
+            825,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Local estimation. In many practical escenarios, we have additional bounds on the input of the network. For example, in the case of image classification tasks, valid input is constrained in a hypercube. In the robustness certification task, we are interested in all possible input in a $\\epsilon$ -ball around some data point. In those cases, it is interesting to compute a local Lipschitz constant, that is, the Lipschitz constant of a function restricted to a subset. ",
+        "bbox": [
+            174,
+            279,
+            825,
+            349
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We can achieve this by deriving tighter bounds $0 \\leq l _ { i } \\leq s _ { i } \\leq u _ { i } \\leq 1$ , as a consequence of the restricted input (see for example, Algorithm 1 in Wong & Kolter (2018)). By incorporating this knowledge in the optimization problem (4) we obtain bounds on local Lipschitz constants of $f _ { d }$ . We study this setting and provide numerical experiments in section 7.3. ",
+        "bbox": [
+            174,
+            354,
+            825,
+            411
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Choice of norm. We highlight the importance of computing good upper bounds on $L ( f _ { d } )$ with respect to the $\\ell _ { \\infty }$ -norm. It is one of the most commonly used norms to assess robustness in the adversarial examples literature. Moreover, it has been shown that, in practice, $\\ell _ { \\infty }$ -norm robust networks are also robust in other more plausible measures of perceptibility, like the Wasserstein distance (Wong et al., 2019). This motivates our focus on this choice. ",
+        "bbox": [
+            173,
+            417,
+            825,
+            488
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 HIERARCHICAL SOLUTION BASED ON A POLYNOMIAL POSITIVITY CERTIFICATE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            508,
+            754,
+            542
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For ease of exposition, we rewrite (4) as a POP constrained in $[ 0 , 1 ] ^ { n }$ using the substitution $s _ { 0 } : = ( t +$ $1 ) / 2$ . Denote by $p$ the norm-gradient polynomial, and let $x = [ s _ { 0 } , \\ldots , s _ { d - 1 } ]$ be the concatenation of all variables. Polynomial optimization methods (Lasserre, 2015) start from the observation that a value $\\lambda$ is an upper bound for $p$ over a set $K$ if and only if the polynomial $\\lambda - p$ is positive over $K$ . ",
+        "bbox": [
+            174,
+            558,
+            823,
+            614
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "In LiPopt, we will employ a well-known classical result in algebraic geometry, the so-called Krivine’s positivity certificate1, but in theory we can use any positivity certificate like sum-of-squares (SOS). The following is a straightforward adaptation of Krivine’s certificate to our setting: ",
+        "bbox": [
+            174,
+            621,
+            825,
+            664
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Theorem 2. (Adapted from Krivine (1964); Stengle (1974); Handelman (1988)) If the polynomial $\\lambda - p$ is strictly positive on $[ 0 , 1 ] ^ { n }$ , then there exist finitely many positive weights $c _ { \\alpha \\beta }$ such that ",
+        "bbox": [
+            171,
+            667,
+            826,
+            696
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/129b32c4644953706b16713c0ee5edf6122c045905a283e94383cccc49410b0a.jpg",
+        "text": "$$\n\\lambda - p = \\sum _ { ( \\alpha , \\beta ) \\in \\mathbb { N } ^ { 2 n } } c _ { \\alpha \\beta } h _ { \\alpha \\beta } , \\qquad h _ { \\alpha \\beta } ( x ) : = \\prod _ { j = 1 } ^ { n } x _ { j } ^ { \\alpha _ { j } } ( 1 - x _ { j } ) ^ { \\beta _ { j } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            292,
+            704,
+            705,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "By truncating the degree of Krivine’s positivity certificate (Theorem 2) and minimizing over all possible upper bounds $\\lambda$ we obtain a hierarchy of LP problems (Lasserre, 2015, Section 9): ",
+        "bbox": [
+            173,
+            762,
+            825,
+            791
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/85ab3fa57f224c695d1d082d0c9f29e80081616bfde85f0870f55fdf44cdd098.jpg",
+        "text": "$$\n\\theta _ { k } : = \\operatorname* { m i n } _ { c \\geq 0 , \\lambda } \\left\\{ \\lambda : \\lambda - p = \\sum _ { ( \\alpha , \\beta ) \\in \\mathbb { N } _ { k } ^ { 2 n } } c _ { \\alpha \\beta } h _ { \\alpha \\beta } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            343,
+            797,
+            653,
+            848
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "where $\\mathbb { N } _ { k } ^ { 2 n }$ is the set of nonnegative integer sequences of length $2 n$ adding up to at most $k$ . This is indeed a sequence of LPs as the polynomial equality constraint can be implemented by equating coefficients in the canonical monomial basis. For this polynomial equality to be feasible, the degree of the certificate has to be at least that of the norm-gradient polynomial $p$ , which is equal to the depth $d$ . This implies that the first nontrivial bound $( \\theta _ { k } < \\infty )$ ) corresponds to $k = d$ . ",
+        "bbox": [
+            174,
+            856,
+            823,
+            900
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The sequence $\\{ \\theta _ { k } \\} _ { k = 1 } ^ { \\infty }$ is non-incresing and converges to the maximum of the upper bound (4). Note that for any level of the hierarchy, the solution of the LP (6) provides a valid upper bound on $L ( f _ { d } )$ . ",
+        "bbox": [
+            171,
+            138,
+            823,
+            167
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "An advantage of using Krivine’s positivity certificate over SOS is that one obtains an LP hierarchy (rather than SDP), for which commercial solvers can reliably handle a large instances. Other positivity certificates offering a similar advantage are the DSOS and SDSOS hierarchies (Ahmadi & Majumdar, 2019), which boil down to LP or second order cone programming (SOCP), respectively. ",
+        "bbox": [
+            174,
+            172,
+            825,
+            229
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Drawback. The size of the LPs given by Krivine’s positivity certificate can become quite large. The dimension of the variable $c$ is $| \\mathbb { N } _ { k } ^ { 2 n } | = { \\dot { \\mathcal { O } } } ( n ^ { k } )$ . For reference, if we consider the MNIST dataset and a one-hidden-layer network with 100 neurons we have $\\left| \\mathbb { N } _ { 2 } ^ { 2 n } \\right| \\approx 1 . 5 \\times 1 0 ^ { 6 }$ while $\\left| \\mathbb { N } _ { 3 } ^ { 2 n } \\right| \\approx 9 . 3 \\times 1 0 ^ { 8 }$ . To make this approach more scalable, in the next section we exploit the sparsity of the polynomial $p$ to find LPs of drastically smaller size than (6), but with similar approximation properties. ",
+        "bbox": [
+            173,
+            236,
+            825,
+            309
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Remark. In order to compute upper bounds for local Lipschitz constants, first obtain tighter bounds $0 \\leq l _ { i } \\leq s _ { i } \\leq u _ { i }$ and then perform the change of variables $\\widetilde { s } _ { i } = ( s _ { i } - l _ { i } ) / ( u _ { i } - l _ { i } )$ to rewrite the problem (4) as a POP constrained on $[ 0 , 1 ] ^ { n }$ . ",
+        "bbox": [
+            174,
+            315,
+            823,
+            358
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "4 REDUCING THE NUMBER OF VARIABLES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            378,
+            540,
+            395
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Many neural network architectures, like those composed of convolutional layers, have a highly sparse connectivity between neurons. Moreover, it has been empirically observed that up to $90 \\%$ of network weights can be pruned (set to zero) without harming accuracy (Frankle & Carbin, 2019). In such cases their norm-gradient polynomial has a special structure that allows polynomial positivity certificates of smaller size than the one given by Krivine’s positivity certificate (Theorem 2). ",
+        "bbox": [
+            174,
+            410,
+            825,
+            481
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this section, we describe an implementation of LiPopt (Algorithm 1) that exploits the sparsity of the network to decrease the complexity of the LPs (6) given by the Krivine’s positivity certificate. In this way, we obtain upper bounds on $L ( f _ { d } )$ that require less computation and memory. Let us start with the definition of a valid sparsity pattern: ",
+        "bbox": [
+            174,
+            486,
+            825,
+            542
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Definition 1. Let $I = \\{ 1 , \\ldots , n \\}$ and $p$ be a polynomial with variable $x \\in \\mathbb { R } ^ { n }$ . A valid sparsity pattern of $p$ is a sequence $\\{ I _ { i } \\} _ { i = 1 } ^ { m }$ of subsets of $I$ , called cliques, such that $\\textstyle \\bigcup _ { i = 1 } ^ { m } I _ { i } = I$ and: ",
+        "bbox": [
+            174,
+            547,
+            821,
+            578
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": ". $\\textstyle p = \\sum _ { i = 1 } ^ { m } p _ { i }$ where $p _ { i }$ is a polynomial that depends only on the variables $\\{ x _ { j } : j \\in I _ { i } \\}$ . for all $i = 1 , \\ldots , m - 1$ there is an $l \\leq i$ such that $\\begin{array} { r } { ( I _ { i + 1 } \\cap \\bigcup _ { r = 1 } ^ { i } I _ { r } ) \\subseteq I _ { l } } \\end{array}$ ",
+        "bbox": [
+            209,
+            588,
+            807,
+            633
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "When the polynomial objective $p$ in a POP has a valid sparsity pattern, there is an extension of Theorem 2 due to Weisser et al. (2018), providing a smaller positivity certificate for $\\lambda - p$ over $[ 0 , 1 ] ^ { n }$ . We refer to it as the sparse Krivine’s certificate and we include it here for completeness: ",
+        "bbox": [
+            174,
+            643,
+            823,
+            686
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Theorem 3 (Adapted from Weisser et al. (2018)). Let a polynomial $p$ have a valid sparsity pattern $\\{ I _ { i } \\} _ { i = 1 } ^ { m }$ . Define $N _ { i }$ as the set of sequences $( \\alpha , \\beta ) \\in \\bar { \\mathbb { N } } ^ { 2 n }$ where the support of both $\\alpha$ and $\\beta$ is contained in $I _ { i }$ . If $\\lambda - p$ is strictly positive over $K = [ 0 , 1 ] ^ { n }$ , there exist finitely many positive weights $c _ { \\alpha \\beta }$ such that ",
+        "bbox": [
+            173,
+            690,
+            825,
+            747
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/fcdf50ff56f4ca85812f18578bf61580b244b879c06374dcd3fc6e93ab8b7e0e.jpg",
+        "text": "$$\n\\lambda - p = \\sum _ { i = 1 } ^ { m } h _ { i } , \\qquad h _ { i } = \\sum _ { ( \\alpha , \\beta ) \\in N _ { i } } c _ { \\alpha \\beta } h _ { \\alpha \\beta }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            338,
+            755,
+            658,
+            799
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "where the polynomials $h _ { \\alpha \\beta }$ are defined as in (5). ",
+        "bbox": [
+            174,
+            805,
+            490,
+            820
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The sparse Krivine’s certificate can be used like the general version (Theorem 2) to derive a sequence of LPs approximating the upper bound on $L ( f _ { d } )$ stated in (4). However, the number of different polynomials $h _ { \\alpha \\beta }$ of degree at most $k$ appearing in the sparse certificate can be drastically smaller, the amount of which determines how good the sparsity pattern is. ",
+        "bbox": [
+            174,
+            832,
+            825,
+            888
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We introduce a graph that depends on the network $f _ { d }$ , from which we will extract a sparsity pattern for the norm-gradient polynomial of a network. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/214b4ec10db794f93e318582922104545dac5f8d93ae013d25d849c225637e9d.jpg",
+        "image_caption": [
+            "Figure 1: Sparsity pattern of Proposition 1 for a network of depth three. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            238,
+            107,
+            423,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/c840ffb3080a0f590ddc61c0b1ed0992fd23d3fa33726a52fedf988a09c2b4b8.jpg",
+        "image_caption": [
+            "Figure 2: Structure of one set in the sparsity pattern from Proposition 1 for a network with 2D convolutional layers with $3 \\times 3$ filters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            575,
+            101,
+            761,
+            226
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Definition 2. Let $f _ { d }$ be a network with weights $\\{ W _ { i } \\} _ { i = 1 } ^ { d }$ . Define a directed graph $G _ { d } = ( V , E )$ as: ",
+        "bbox": [
+            173,
+            303,
+            823,
+            320
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1e6de452fb7d0105bd4ab2196f6da58a08f35b8fe1d242cc21e870607d5ddd58.jpg",
+        "text": "$$\n\\begin{array} { c } { { V = \\{ s _ { i , j } : 0 \\leq i \\leq d - 1 , 1 \\leq j \\leq n _ { i } \\} } } \\\\ { { E = \\{ ( s _ { i , j } , s _ { i + 1 , k } ) : 0 \\leq i \\leq d - 2 , [ W _ { i } ] _ { k , j } \\neq 0 \\} } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            331,
+            327,
+            666,
+            363
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "which we call the computational graph of the network $f _ { d }$ ",
+        "bbox": [
+            176,
+            364,
+            549,
+            378
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "In the graph $G _ { d }$ the vertex $s _ { ( i , j ) }$ represents the $j$ -th neuron in the $i$ -th layer. There is a directed edge between two neurons in consecutive layers if they are joined by a nonzero weight in the network. The following result shows that for fully connected networks we can extract a valid sparsity pattern from this graph. We relegate the proof to appendix B. ",
+        "bbox": [
+            174,
+            390,
+            826,
+            445
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Proposition 1. Let $f _ { d }$ be a dense network (all weights are nonzero). The following sets, indexed by $i = 1 , \\ldots , n _ { d } ,$ form a valid sparsity pattern for the norm-gradient polynomial of the network $f _ { d }$ : ",
+        "bbox": [
+            173,
+            449,
+            823,
+            478
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e00aa72600f1772a52650432929c0d6a675d1891a3d4f35dc2108c5bd78fe522.jpg",
+        "text": "$$\nI _ { i } : = \\left\\{ s _ { ( d - 1 , i ) } \\right\\} \\cup \\left\\{ s _ { ( j , k ) } : t h e r e \\ e x i s t s a \\ d i r e c t e d p a t h f r o m \\ s _ { ( j , k ) } \\ t o \\ s _ { ( d - 1 , i ) } \\ i n \\ G _ { d } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            218,
+            481,
+            779,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We refer to this as the sparsity pattern induced by $G _ { d }$ . An example is depicted in in Figure 1. ",
+        "bbox": [
+            174,
+            511,
+            781,
+            526
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Remark. When the network is not dense, the the second condition (Definition 1) for the sparsity pattern (9) to be valid might not hold. In that case we lose the guarantee that the values of the corresponding LPs converge to the maximum of the POP (4). Nevertheless, it still provides a valid positivity certificate that we use to upper bound $L ( f _ { d } )$ . In Section 7 we show that in practice it provides upper bounds of good enough quality. If needed, a valid sparsity pattern can be obtained via a chordal completion of the correlative sparsity graph of the POP (Waki et al., 2006). ",
+        "bbox": [
+            173,
+            532,
+            825,
+            617
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We now quantify how good this sparsity pattern is. Let $s$ be the size of the largest clique in a sparsity pattern, and let $N _ { i , k }$ be the subset of $N _ { i }$ (defined in Theorem 3) composed of sequences summing up to $k$ . The number of different polynomials for the $k$ -th LP in the hierarchy given by the sparse Krivine’s certificate can be bounded as follows: ",
+        "bbox": [
+            173,
+            623,
+            825,
+            679
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1605b4d5612c218f1773d81f12f4c2fc096d0a6a1d3dcecb82971dfcd7819f11.jpg",
+        "text": "$$\n\\left| \\bigcup _ { i = 1 } ^ { m } N _ { i , k } \\right| \\leq \\sum _ { i = 1 } ^ { m } { \\binom { 2 | I _ { i } | + k } { k } } = \\mathcal { O } \\left( m s ^ { k } \\right)\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            681,
+            640,
+            724
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We immediately see that the dependence on the number of cliques $m$ is really mild (linear) but the size of the cliques as well as the degree of the hierarchy can really impact the size of the optimization problem. Nevertheless, this upper bound can be quite loose; polynomials $h _ { \\alpha \\beta }$ that depend only on variables in the intersection of two or more cliques are counted more than once. ",
+        "bbox": [
+            173,
+            728,
+            823,
+            785
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "The number of cliques given in the sparsity pattern induced by $G _ { d }$ is equal to the size of the last layer $m = n _ { d }$ and the size of each clique depends on the particular implementation of the network. We now study different architectures that could arise in practice, and determine the amount of polynomials in their sparse Krivine’s certificate. ",
+        "bbox": [
+            173,
+            790,
+            825,
+            848
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Fully connected networks. Even in the case of a network with all nonzero connections, the sparsity pattern induced by $G _ { d }$ decreases the size of the LPs when compared to Krivine’s certificate. In this case the cliques have size $n _ { 1 } + . . . + n _ { d - 1 } + 1$ but they all have the same common intersection equal to all neurons up to the second-to-last hidden layer. A straightforward counting argument shows that the total number of polynomials is $\\mathcal { O } ( n ( n _ { 1 } + . . . + n _ { d - 1 } + \\bar { 1 } ) ^ { k - 1 } )$ ), improving the upper bound (10). ",
+        "bbox": [
+            174,
+            853,
+            825,
+            925
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Unstructured sparsity. In the case of networks obtained by pruning (Hanson & Pratt, 1989) or generated randomly from a distribution over graphs (Xie et al., 2019), the sparsity pattern can be arbitrary. In this case the size of the resulting LPs varies at runtime. Under the layer-wise assumption that any neuron is connected to at most $r$ neurons in the previous layer, the size of the cliques in (9) is bounded as $s = \\mathcal { O } ( r ^ { d } )$ . This estimate has an exponential dependency on the depth but ignores that many neurons might share connections to the same inputs in the previous layer, thus being potentially loose. The bound (10) implies that the number of different polynomials is $\\mathcal { O } ( n _ { d } r ^ { d k } )$ . ",
+        "bbox": [
+            173,
+            103,
+            825,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "2D Convolutional networks. The sparsity in the weight matrices of convolutional layers has a certain local structure; neurons are connected to contiguous inputs in the previous layer. Adjacent neurons also have many input pixels in common (see Figure 2). Assuming a constant number of channels per layer, the size of the cliques in (9) is $\\mathcal { O } ( d ^ { 3 } )$ . Intuitively, such number is proportional to the volume of the pyramid depicted in Figure 2 where each dimension depends linearly on $d$ . Using (10) we get that there are $\\mathcal { O } ( \\dot { n } _ { d } d ^ { 3 k } )$ different polynomials in the sparse Krivine’s certificate. This is a drastic decrease in complexity when compared to the unstructured sparsity case. ",
+        "bbox": [
+            173,
+            208,
+            825,
+            306
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "The use of sparsity in polynomial optimization preceeds Theorem 3 (Weisser et al., 2018). First studied in the context of sum-of-squares by Kojima et al. (2005) and further refined in Waki et al. (2006); Lasserre (2006) (and references therein), it has found applications in safety verification (Yang et al., 2016; Zhang et al., 2018), sensor localization Wang et al. (2006), optimal power flow (Ghaddar et al., 2015) and many others. Our work fits precisely into this set of important applications. ",
+        "bbox": [
+            173,
+            311,
+            825,
+            382
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Algorithm 1 LiPopt for ELU activations and sparsity pattern ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            396,
+            578,
+            411
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Input: matrices $\\{ W _ { i } \\} _ { i = 1 } ^ { d }$ , sparsity pattern $\\{ I _ { i } \\} _ { i = 1 } ^ { m }$ , hierarchy degree $k$ .   \n1: p ← (2s0 − 1)T W T1 Qd−1i=1 $\\triangleright$ compute norm-gradient polynomial   \n2: $x \\gets [ s _ { 0 } , \\ldots , s _ { d - 1 } ]$   \n3: $b  [ b _ { \\gamma } : \\gamma \\in \\mathbb { N } _ { k } ^ { n } ]$ where $\\begin{array} { r } { p ( x ) = \\sum _ { \\gamma \\in \\mathbb { N } _ { k } ^ { n } } b _ { \\gamma } x ^ { \\gamma } } \\end{array}$ $\\triangleright$ compute coefficients of $p$ in basis   \n4: for $i = 1 , \\ldots , m$ do   \n5: $N _ { i , k } \\gets \\{ ( \\alpha , \\beta ) \\in \\mathbb { N } _ { k } ^ { 2 n } : \\operatorname { s u p p } ( \\alpha ) \\cap \\operatorname { s u p p } ( \\beta ) \\subseteq I _ { i } \\}$   \n6: $\\widetilde { N } _ { k } \\gets \\cup _ { i = 1 } ^ { m } N _ { i , k }$   \n7: $\\begin{array} { r } { h  \\sum _ { ( \\alpha , \\beta ) \\in \\widetilde { N } } c _ { \\alpha \\beta } h _ { \\alpha \\beta } } \\end{array}$ . compute positivity certificate   \n8: $c  [ c _ { \\alpha \\beta } : ( \\alpha , \\beta ) \\in \\widetilde { N } _ { k } ] ; \\ y  [ \\lambda , c ]$ $\\triangleright$ linear program variables   \n9: $Z \\gets [ z _ { \\gamma } ] _ { \\gamma \\in \\mathbb { N } _ { k } ^ { n } }$ where $\\begin{array} { r } { \\lambda - h ( x ) = \\sum _ { \\gamma \\in \\mathbb { N } _ { k } ^ { n } } ( z _ { \\gamma } ^ { T } y ) x ^ { \\gamma } } \\end{array}$ $\\triangleright$ compute coefficients of $\\lambda - h$ in basis   \nreturn $\\operatorname* { m i n } \\{ \\lambda : b = Z y$ , $y = [ \\lambda , c ]$ , $c \\geq 0 \\}$ $\\triangleright$ solve LP ",
+        "bbox": [
+            179,
+            415,
+            826,
+            597
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "5 QCQP REFORMULATION AND SHOR’S SDP RELAXATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            631,
+            679,
+            648
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Another way of upper bounding $L ( f _ { d } )$ comes from a further relaxation of (4) to an SDP. We consider the following equivalent formulation where the variables $s _ { i }$ are normalized to lie in the interval $[ - 1 , 1 ]$ , and we rename $t = s _ { 0 }$ : ",
+        "bbox": [
+            174,
+            662,
+            825,
+            705
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a92dcd5872f8f32c29cb12ddae91e20b5069f6a226343e3f05057bb3fc98632b.jpg",
+        "text": "$$\nL ( f _ { d } ) \\leq \\operatorname* { m a x } \\left\\{ \\frac { 1 } { 2 ^ { d - 1 } } s _ { 0 } ^ { T } W _ { 1 } ^ { T } \\prod _ { i = 1 } ^ { d - 1 } \\mathrm { D i a g } ( s _ { i } + 1 ) W _ { i + 1 } ^ { T } : - 1 \\leq s _ { i } \\leq 1 \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            269,
+            709,
+            728,
+            752
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Any polynomial optimization problem like (11) can be cast as a (possibly non-convex) quadratically constrained quadratic program (QCQP) by introducing new variables and quadratic constraints. This is a well-known procedure described in Park & Boyd (2017, Section 2.1). When $d = 2$ problem (11) is already a QCQP (for the $\\ell _ { \\infty }$ and $\\ell _ { 2 }$ -norm cases) and no modification is necessary. ",
+        "bbox": [
+            174,
+            756,
+            825,
+            813
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "QCQP reformulation. We illustrate the case $d = 3$ where we have the variables $s _ { 1 } , s _ { 2 }$ corresponding to the first and second hidden layer and a variable $s _ { 0 }$ corresponding to the input. The norm-gradient polynomial in this case is cubic, and it can be rewritten as a quadratic polynomial by introducing new variables corresponding to the product of the first and second hidden layer variables. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            875
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "More precisely the introduction of a variable $s _ { 1 , 2 }$ with quadratic constraint $s _ { 1 , 2 } = \\mathrm { v e c } ( s _ { 1 } s _ { 2 } ^ { T } )$ allows us to write the objective (11) as a quadratic polynomial. The problem then becomes a QCQP with variable $y = [ 1 , s _ { 0 } , s _ { 1 } , s _ { 2 } , s _ { 1 , 2 } ]$ of dimension $1 + n + n _ { 1 } n _ { 2 }$ . ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "SDP relaxation. Any quadratic objective and constraints can then be relaxed to linear constraints on the positive semidefinite variable $y y ^ { T } = X \\succcurlyeq 0$ yielding the so-called Shor’s relaxation of (11) (Park & Boyd, 2017, Section 3.3). When $d = 2$ the resulting SDP corresponds precisely to the one studied in Raghunathan et al. (2018a). This resolves a common misconception (Raghunathan et al., 2018b) that this approach is only limited to networks with one hidden layer. ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Note that in our setting we are only interested in the optimal value rather than the optimizers, so there is no need to extract a solution for (11) from that of the SDP relaxation. ",
+        "bbox": [
+            173,
+            180,
+            823,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Drawback. This approach includes a further relaxation step from (11), thus being fundamentally limited in how tightly it can upper bound the value of $L ( f _ { d } )$ . Moreover when compared to LP solvers, off-the-shelf semidefinite programming solvers are, in general, much more limited in the number of variables they can efficiently handle. ",
+        "bbox": [
+            174,
+            215,
+            825,
+            271
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the case $d = 2$ this relaxation provides a constant factor approximation to the original QCQP (Ye, 1999). Further approximation quality results for such hierarchical optimization approaches to NP-hard problems are out of the scope of this work. ",
+        "bbox": [
+            176,
+            279,
+            823,
+            320
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Relation to sum-of-squares. The QCQP approach might appear fundamentaly different to the hierarchical optimization approaches to POPs, like the one described in Section 3. However, it is known that Shor’s SDP relaxation corresponds exactly to the first degree of the SOS hierarchical SDP solution to the QCQP relaxation (Lasserre, 2000). Thus, the approach in section 3 and the one in this section are, in essence, the same; they only differ in the choice of polynomial positivity certificate. ",
+        "bbox": [
+            174,
+            327,
+            825,
+            411
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "6 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            341,
+            448
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Estimation of $L ( f _ { d } )$ with $\\ell _ { 2 }$ -norm is studied by Virmaux & Scaman (2018); Combettes & Pesquet (2019); Fazlyab et al. (2019); Jin & Lavaei (2018). The method SeqLip proposed in Virmaux & Scaman (2018) has the drawback of not providing true upper bounds. It is in fact a heuristic method for solving (4) but which provides no guarantees and thus can not be used for robustness certification. In contrast the LipSDP method of Fazlyab et al. (2019) provides true upper bounds on $L ( f _ { d } )$ and in practice shows superior performance over both SeqLip and CPLip (Combettes & Pesquet, 2019). ",
+        "bbox": [
+            174,
+            463,
+            825,
+            547
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Despite the accurate estimation of LipSDP, its formulation is limited to the $\\ell _ { 2 }$ -norm. The only estimate available for other $\\ell _ { p }$ -norms comes from the equivalence of norms in euclidean spaces. For instance, we can obtain an upper bound for the $\\ell _ { \\infty }$ -norm after multiplying the $\\ell _ { 2 }$ Lipschitz constant upper bound by the square root of the input dimension. The resulting bound can be rather loose and our experiments in section 7 confirm the issue. In contrast, our proposed approach LiPopt can acommodate any norm whose unit ball can be described via polynomial inequalities. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            638
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Let us point to one key advantage of LiPopt, compared to LipSDP (Jin & Lavaei, 2018; Fazlyab et al., 2019). In the context of robustness certification we are given a sample $x ^ { \\sharp }$ and a ball of radius $\\epsilon$ around it. Computing an upper bound on the local Lipschitz constant in this subset, rather than a global one, can provide a larger region of certified robustness. Taking into account the restricted domain we can refine the bounds in our POP (see remark in section 1). This potentially yields a tighter estimate of the local Lipschitz constant. On the other hand, it is not clear how to include such additional information in LipSDP, which only computes one global bound on the Lipschitz constant for the unconstrained network. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            756
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Raghunathan et al. (2018a) find an upper bound for $L ( f _ { d } )$ with $\\ell _ { \\infty }$ metric starting from problem (4) but only in the context of one-hidden-layer networks $\\ Q = 2 ,$ ). To compute such bound they use its corresponding Shor’s relaxation and obtain as a byproduct a differentiable regularizer for training networks. They claim such approach is limited to the setting $d = 2$ but, as we remark in section 5, it is just a particular instance of the SDP relaxation method for QCQPs arising from a polynomial optimization problem. We find that this method fits into the LiPopt framework, using SOS certificates instead of Krivine’s. We expect that the SDP-based bounds described in 5 can also be used as regularizers promoting robustness. ",
+        "bbox": [
+            173,
+            762,
+            825,
+            875
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Weng et al. (2018) provide an upper bound on the local Lipschitz constant for networks based on a sequence of ad-hoc bounding arguments, which are particular to the choice of ReLU activation function. In contrast, our approach applies in general to activations whose derivative is bounded. ",
+        "bbox": [
+            176,
+            882,
+            823,
+            924
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "7 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            328,
+            118
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We consider the following estimators of $L ( f _ { d } )$ with respect to the $\\ell _ { \\infty }$ norm: ",
+        "bbox": [
+            174,
+            135,
+            671,
+            150
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/e03d448dda6e959c59199c79a3d624f826935996a0764afbac9c989df4e22337.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Name</td><td rowspan=1 colspan=1>Description</td></tr><tr><td rowspan=1 colspan=1>SDP</td><td rowspan=1 colspan=1>Upper bound arising from the solution of the SDP relaxation described in Sec-tion 5</td></tr><tr><td rowspan=1 colspan=1>LipOpt-k</td><td rowspan=1 colspan=1>Upper bound arising from the k-th degree of the LP hierarchy (6) based on thesparse Krivine Positivstellenstatz.</td></tr><tr><td rowspan=1 colspan=1>Lip-SDP</td><td rowspan=1 colspan=1>Upper bound from Fazlyab et al. (2019) multiplied √d where d is the inputdimension of the network.</td></tr><tr><td rowspan=1 colspan=1>UBP</td><td rowspan=1 colspan=1>Upper bound determined by the product of the layer-wise Lipschitz constantswith loometric</td></tr><tr><td rowspan=1 colspan=1>LBS</td><td rowspan=1 colspan=1>Lower bound obtained by sampling 5oooO random points around zero, andevaluating the dual norm of the gradient</td></tr></table>",
+        "bbox": [
+            187,
+            161,
+            808,
+            321
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "7.1 EXPERIMENTS ON RANDOM NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            339,
+            490,
+            353
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We compare the bounds obtained by the algorithms described above on networks with random weights and either one or two hidden layers. We define the sparsity level of a network as the maximum number of neurons any neuron in one layer is connected to in the next layer. For example, the network represented on Figure 1 has sparsity 2. The non-zero weights of network’s $i$ -th layer are sampled uniformly in $[ - \\frac { \\breve { 1 } } { \\sqrt { n _ { i } } } , \\frac { 1 } { \\sqrt { n _ { i } } } ]$ where $n _ { i }$ is the number of neurons in layer $i$ . ",
+        "bbox": [
+            174,
+            366,
+            825,
+            439
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For different configurations of width and sparsity, we generate 10 random networks and average the obtained Lipschitz bounds. For better comparison, we plot the relative error. Since we do not know the true Lipschitz constant, we cannot compute the true relative error. Instead, we take as reference the lower bound given by LBS. Figures 3 and 5 show the relative error, i.e., $( \\hat { L } - L _ { L B S } ) / L _ { L B S }$ where $L _ { L B S }$ is the lower bound computed by LBS and $\\hat { L }$ is the estimated upper bound. Figures 9 and 10 in Appendix C we show the values of the computed Lipschitz bounds for 1 and 2 hidden layers respectively. ",
+        "bbox": [
+            173,
+            445,
+            825,
+            547
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "When the chosen degree for LiPopt-k is the smallest as possible, i.e., equal to the depth of the network, we observe that the method is already competitive with the SDP method, especially in the case of 2 hidden layers. When we increment the degree by 1, LiPopt-k becomes uniformly better than SDP over all tested configurations. We remark that the upper bounds given by UBP are too large to be shown in the plots. Similarly, for the 1-hidden layer networks, the bounds from LipSDP are too large to be plotted. ",
+        "bbox": [
+            174,
+            554,
+            825,
+            638
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Finally, we measured the computation time of the different methods on each tested network (Figures 4 and 6). We observe that the computation time for LiPopt-k heavily depends on the network sparsity, which reflects the fact that such structure is exploited in the algorithm. In contrast, the time required for SDP does not depend on the sparsity, but only on the size of the network. Therefore as the network size grows (with fixed sparsity level), LipOpt-k obtains a better upper bound and runs faster. Also, with our method, we see that it is possible to increase the computation power in order to compute tighter bounds when required, making it more flexible than SDP in terms of computation/accuracy tradeoff. LiPopt uses the Gurobi LP solver, while SDP uses Mosek. All methods run on a single machine with Core i7 2.8Ghz quad-core processor and 16Gb of RAM. ",
+        "bbox": [
+            173,
+            645,
+            825,
+            771
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/36715696c6d13101074bebdd53e4699329e7143885a21b2eaae6a91eea796e9d.jpg",
+        "image_caption": [
+            "Figure 3: Lipschitz approximated relative error for 1-hidden layer networks "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            785,
+            802,
+            885
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/16f4460aa96107ed8b842356f329b5f9c62f18f106042c719ca032bde18b336b.jpg",
+        "image_caption": [
+            "Figure 4: Computation times for 1-hidden layer networks (seconds) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            101,
+            800,
+            202
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/688cbbb935006042a5b738de27979cf8fb8ddd23c626da768e5bb13bf7dbf66b.jpg",
+        "image_caption": [
+            "Figure 5: Lipschitz approximated relative error for 2-hidden layer networks "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            241,
+            800,
+            340
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/2913548161f337fdbd03d9ad1bbad83e6f237e8215410cc7e959db088133e3f3.jpg",
+        "image_caption": [
+            "Figure 6: Computation times for 2-hidden layer networks (seconds) "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            381,
+            800,
+            481
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.2 EXPERIMENTS ON TRAINED NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            178,
+            534,
+            490,
+            546
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Similarly, we compare these methods on networks trained on MNIST. The architecture we use is a fully connected network with two hidden layers with 300 and 100 neurons respectively, and with one-hot output of size 10. Since the output is multi-dimensional, we restrict the network to a single output, and estimate the Lipschitz constant with respect to label 8. ",
+        "bbox": [
+            174,
+            559,
+            825,
+            614
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Moreover, in order to improve the scalability of our method, we train the network using the pruning strategy described in Han et al. $( 2 0 1 5 ) ^ { 2 }$ . After training the full network using a standard technique, the weights of smallest magnitude are set to zero. Then, the network is trained for additional iterations, only updating the nonzero parameters. Doing so, we were able to remove $9 5 \\%$ of the weights, while preserving the same test accuracy. We recorded the Lipschitz bounds for various methods in Table 7.2. We observe clear improvement of the Lipschitz bound obtained from LiPopt-k compared to SDP method, even when using $k = 3$ . Also note that the input dimension is too large for the method Lip-SDP to provide competitive bound, so we do not provide the obtained bound for this method. ",
+        "bbox": [
+            173,
+            622,
+            825,
+            747
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/5c9e6703311909e83ec421e16b97c0ae23b2c72f5204afd3ee85185349ca221c.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>LBS</td><td rowspan=1 colspan=1>LiPopt-4</td><td rowspan=1 colspan=1>LiPopt-3</td><td rowspan=1 colspan=1>SDP</td><td rowspan=1 colspan=1>UBP</td></tr><tr><td rowspan=1 colspan=1>Lipschitz bound</td><td rowspan=1 colspan=1>84.2</td><td rowspan=1 colspan=1>88.3</td><td rowspan=1 colspan=1>94.6</td><td rowspan=1 colspan=1>98.8</td><td rowspan=1 colspan=1>691.5</td></tr></table>",
+        "bbox": [
+            272,
+            757,
+            717,
+            790
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "7.3 ESTIMATING LOCAL LIPSCHITZ CONSTANTS WITH LIPOPT ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            804,
+            619,
+            819
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In the of section 7.1, we study the improvement on the upper bound obtained by LiPopt, when we incorporate tighter upper and lower bounds on the variables $s _ { i }$ of the polynomial optimization problem (4). Such bounds arise from the limited range that the pre-activation values of the network can take, when the input is limited to an $\\ell _ { \\infty }$ -norm ball of radius $\\epsilon$ centered at an arbitrary point $x _ { 0 }$ . ",
+        "bbox": [
+            173,
+            830,
+            825,
+            887
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "The algorithm that computes upper and lower bounds on the pre-activation values is fast (it has the same complexity as a forward pass) and is described, for example, in Wong & Kolter (2018). The variables $s _ { i }$ correspond to the value of the derivative of the activation function. For activations like ELU or ReLU, their derivative is monotonically increasing, so we need only evaluate it at the upper and lower bounds of the pre-activation values to obtain corresponding bounds for the variables $s _ { i }$ . ",
+        "bbox": [
+            174,
+            103,
+            825,
+            174
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "We plot the local upper bounds obtained by LiPopt-3 for increasing values of the radius $\\epsilon$ , the bound for the global constant (given by LiPopt-3) and the lower bound on the local Lipschitz constant obtained by sampling in the $\\epsilon$ -neighborhood (LBS). We sample 15 random networks and plot the average values obtained. We observe clear gap between both estimates, which shows that larger certified balls could be obtained with such method in the robustness certification applications. ",
+        "bbox": [
+            174,
+            180,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/caca3de17318ea9710940bfd4d6d9c624bdb96ef7815b200478040db061a5551.jpg",
+        "image_caption": [
+            "Figure 7: Global vs local Lipschitz constant bounds for 1-hidden layer networks "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            196,
+            267,
+            803,
+            369
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/adac380da60ee5e5deb213f94cacd68bbe4c0a5ffac2336cfd61a636727ca433.jpg",
+        "image_caption": [
+            "Figure 8: Global vs local Lipschitz constant bounds for 2-hidden layer networks "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            430,
+            803,
+            534
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "8 CONCLUSION AND FUTURE WORK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            598,
+            486,
+            613
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In this work, we have introduced a general approach for computing an upper bound on the Lipschitz constant of neural networks. This approach is based on polynomial positivity certificates and generalizes some existing methods available in the literature. We have empirically demonstrated that it can tightly upper bound such constant. The resulting optimization problems are computationally expensive but the sparsity of the network can reduce this burden. ",
+        "bbox": [
+            173,
+            632,
+            823,
+            702
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "In order to further scale such methods to larger and deeper networks, we are interested in several possible directions: $( i )$ divide-and-conquer approaches splitting the computation on sub-networks in the same spirit of Fazlyab et al. (2019), $( i i )$ exploiting parallel optimization algorithms leveraging the structure of the polynomials, $( i i i )$ custom optimization algorithms with low-memory costs such as Frank-wolfe-type methods for SDP (Yurtsever et al., 2019) as well as stochastic handling of constraints (Fercoq et al., 2019) and $( i v )$ , exploting the symmetries in the polynomial that arise from weight sharing in typical network architectures to further reduce the size of the problems. ",
+        "bbox": [
+            174,
+            709,
+            825,
+            806
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "ACKNOWLEDGMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            828,
+            326,
+            842
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "This project has received funding from the European Research Council (ERC) under the European Union’s Horizon 2020 research and innovation programme (grant agreement 725594 - time-data) and from the Swiss National Science Foundation (SNSF) under grant number 200021 178865. FL is supported through a PhD fellowship of the Swiss Data Science Center, a joint venture between EPFL and ETH Zurich. VC acknowledges the 2019 Google Faculty Research Award. ",
+        "bbox": [
+            176,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES   \nA. Ahmadi and A. Majumdar. Dsos and sdsos optimization: More tractable alternatives to sum of squares and semidefinite optimization. SIAM Journal on Applied Algebra and Geometry, 3(2):193–230, 2019. doi: 10.1137/18M118935X. URL https://doi.org/10.1137/ 18M118935X.   \nCem Anil, James Lucas, and Roger Grosse. Sorting out Lipschitz function approximation. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 291–301, Long Beach, California, USA, 09–15 Jun 2019. PMLR.   \nMartin Arjovsky, Soumith Chintala, and Leon Bottou. Wasserstein generative adversarial networks. ´ In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 214–223, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR.   \nPeter L Bartlett, Dylan J Foster, and Matus J Telgarsky. Spectrally-normalized margin bounds for neural networks. In Advances in Neural Information Processing Systems 30, pp. 6240–6249. Curran Associates, Inc., 2017.   \nFelix Berkenkamp, Matteo Turchetta, Angela Schoellig, and Andreas Krause. Safe model-based reinforcement learning with stability guarantees. In Advances in Neural Information Processing Systems 30, pp. 908–918. Curran Associates, Inc., 2017.   \nMoustapha Cisse, Piotr Bojanowski, Edouard Grave, Yann Dauphin, and Nicolas Usunier. Parseval networks: Improving robustness to adversarial examples. In Proceedings of the 34th International Conference on Machine Learning, volume 70 of Proceedings of Machine Learning Research, pp. 854–863, International Convention Centre, Sydney, Australia, 06–11 Aug 2017. PMLR.   \nDjork-Arne Clevert, Thomas Unterthiner, and Sepp Hochreiter. Fast and Accurate Deep Network ´ Learning by Exponential Linear Units (ELUs). arXiv e-prints, art. arXiv:1511.07289, Nov 2015.   \nPatrick L. Combettes and Jean-Christophe Pesquet. Lipschitz Certificates for Neural Network Structures Driven by Averaged Activation Operators. arXiv e-prints, art. arXiv:1903.01014, Mar 2019.   \nMahyar Fazlyab, Alexander Robey, Hamed Hassani, Manfred Morari, and George J. Pappas. Efficient and Accurate Estimation of Lipschitz Constants for Deep Neural Networks. arXiv e-prints, art. arXiv:1906.04893, Jun 2019.   \nOlivier Fercoq, Ahmet Alacaoglu, Ion Necoara, and Volkan Cevher. Almost surely constrained convex optimization. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 1910–1919, Long Beach, California, USA, 09–15 Jun 2019. PMLR.   \nJonathan Frankle and Michael Carbin. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2019.   \nBissan Ghaddar, Jakub Marecek, and Martin Mevissen. Optimal power flow as a polynomial optimization problem. IEEE Transactions on Power Systems, 31(1):539–546, 2015.   \nIshaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron C Courville. Improved training of wasserstein gans. In Advances in Neural Information Processing Systems 30, pp. 5767–5777. Curran Associates, Inc., 2017.   \nSong Han, Huizi Mao, and William J Dally. Deep compression: Compressing deep neural networks with pruning, trained quantization and huffman coding. arXiv preprint arXiv:1510.00149, 2015.   \nDavid Handelman. Representing polynomials by positive linear functions on compact convex polyhedra. Pacific J. Math., 132(1):35–62, 1988. URL https://projecteuclid.org: 443/euclid.pjm/1102689794.   \nStephen Jose Hanson and Lorien Y. Pratt. Comparing biases for minimal network construction with back-propagation. In Advances in Neural Information Processing Systems 1, pp. 177–185. Morgan-Kaufmann, 1989. ",
+        "bbox": [
+            171,
+            78,
+            826,
+            931
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition, pp. 770–778, 06 2016. doi: 10.1109/CVPR.2016.90. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            146
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Todd Huster, Cho-Yu Jason Chiang, and Ritu Chadha. Limitations of the Lipschitz constant as a defense against adversarial examples. arXiv e-prints, art. arXiv:1807.09705, Jul 2018. ",
+        "bbox": [
+            173,
+            156,
+            823,
+            185
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Ming Jin and Javad Lavaei. Stability-certified reinforcement learning: A control-theoretic perspective. arXiv e-prints, art. arXiv:1810.11505, Oct 2018. ",
+        "bbox": [
+            173,
+            195,
+            820,
+            224
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Masakazu Kojima, Sunyoung Kim, and Hayato Waki. Sparsity in sums of squares of polynomials. Mathematical Programming, 103(1):45–62, May 2005. ISSN 1436-4646. doi: 10.1007/s10107-004-0554-3. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            276
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jean-Louis Krivine. Anneaux preordonn ´ es. ´ Journal d’analyse mathematique ´ , 12:p. 307–326, 1964. ",
+        "bbox": [
+            169,
+            287,
+            823,
+            304
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "J. B. Lasserre. Convergent lmi relaxations for nonconvex quadratic programs. In Proceedings of the 39th IEEE Conference on Decision and Control (Cat. No.00CH37187), volume 5, pp. 5041–5046 vol.5, Dec 2000. doi: 10.1109/CDC.2001.914738. ",
+        "bbox": [
+            173,
+            313,
+            823,
+            356
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jean B Lasserre. Convergent sdp-relaxations in polynomial optimization with sparsity. SIAM Journal on Optimization, 17(3):822–843, 2006. ",
+        "bbox": [
+            166,
+            366,
+            823,
+            395
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jean Bernard Lasserre. An Introduction to Polynomial and Semi-Algebraic Optimization. Cambridge Texts in Applied Mathematics. Cambridge University Press, 2015. doi: 10.1017/ CBO9781107447226. ",
+        "bbox": [
+            173,
+            405,
+            825,
+            448
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Y. Lecun, L. Bottou, Y. Bengio, and P. Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, Nov 1998. doi: 10.1109/5.726791. ",
+        "bbox": [
+            174,
+            458,
+            821,
+            488
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Takeru Miyato, Toshiki Kataoka, Masanori Koyama, and Yuichi Yoshida. Spectral normalization for generative adversarial networks. In International Conference on Learning Representations, 2018. ",
+        "bbox": [
+            173,
+            497,
+            825,
+            540
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Jaehyun Park and Stephen Boyd. General heuristics for nonconvex quadratically constrained quadratic programming. arXiv preprint arXiv:1703.07870, 2017. ",
+        "bbox": [
+            168,
+            551,
+            825,
+            580
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Jacob Steinhardt, and Percy Liang. Certified defenses against adversarial examples. In International Conference on Learning Representations, 2018a. ",
+        "bbox": [
+            171,
+            590,
+            823,
+            619
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aditi Raghunathan, Jacob Steinhardt, and Percy S Liang. Semidefinite relaxations for certifying robustness to adversarial examples. In Advances in Neural Information Processing Systems, pp. 10877–10887, 2018b. ",
+        "bbox": [
+            174,
+            628,
+            823,
+            672
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Gilbert Stengle. A nullstellensatz and a positivstellensatz in semialgebraic geometry. Mathematische Annalen, 207(2):87–97, Jun 1974. ISSN 1432-1807. doi: 10.1007/BF01362149. ",
+        "bbox": [
+            173,
+            683,
+            821,
+            712
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Christian Szegedy, Wojciech Zaremba, Ilya Sutskever, Joan Bruna, Dumitru Erhan, Ian J. Goodfellow, and Rob Fergus. Intriguing properties of neural networks. In 2nd International Conference on Learning Representations, ICLR 2014, Banff, AB, Canada, April 14-16, 2014, Conference Track Proceedings, 2014. ",
+        "bbox": [
+            173,
+            722,
+            825,
+            779
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Aladin Virmaux and Kevin Scaman. Lipschitz regularity of deep neural networks: analysis and efficient estimation. In Advances in Neural Information Processing Systems 31, pp. 3835–3844. Curran Associates, Inc., 2018. ",
+        "bbox": [
+            173,
+            787,
+            823,
+            832
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "H. Waki, S. Kim, M. Kojima, and M. Muramatsu. Sums of squares and semidefinite program relaxations for polynomial optimization problems with structured sparsity. SIAM Journal on Optimization, 17(1):218–242, 2006. doi: 10.1137/050623802. ",
+        "bbox": [
+            174,
+            842,
+            823,
+            885
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Zizhuo Wang, Song Zheng, Stephen Boyd, and Yinyu Ye. Further relaxations of the sdp approach to sensor network localization. Tech. Rep., 2006. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "Tillmann Weisser, Jean B Lasserre, and Kim-Chuan Toh. Sparse-bsos: a bounded degree sos hierarchy for large scale polynomial optimization with sparsity. Mathematical Programming Computation, 10(1):1–32, 2018. ",
+        "bbox": [
+            176,
+            103,
+            821,
+            145
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Lily Weng, Huan Zhang, Hongge Chen, Zhao Song, Cho-Jui Hsieh, Luca Daniel, Duane Boning, and Inderjit Dhillon. Towards fast computation of certified robustness for ReLU networks. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 5276–5285, Stockholmsmassan, Stockholm Sweden, 10–15 ¨ Jul 2018. PMLR. ",
+        "bbox": [
+            173,
+            155,
+            825,
+            224
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong and Zico Kolter. Provable defenses against adversarial examples via the convex outer adversarial polytope. In Proceedings of the 35th International Conference on Machine Learning, volume 80 of Proceedings of Machine Learning Research, pp. 5286–5295, Stockholmsmassan, ¨ Stockholm Sweden, 10–15 Jul 2018. PMLR. ",
+        "bbox": [
+            173,
+            234,
+            825,
+            290
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Eric Wong, Frank Schmidt, and Zico Kolter. Wasserstein adversarial examples via projected Sinkhorn iterations. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 6808–6817, Long Beach, California, USA, 09–15 Jun 2019. PMLR. ",
+        "bbox": [
+            173,
+            299,
+            825,
+            356
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Saining Xie, Alexander Kirillov, Ross Girshick, and Kaiming He. Exploring Randomly Wired Neural Networks for Image Recognition. International Conference on Computer Vision, Apr 2019. ",
+        "bbox": [
+            174,
+            364,
+            825,
+            407
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Zhengfeng Yang, Chao Huang, Xin Chen, Wang Lin, and Zhiming Liu. A linear programming relaxation based approach for generating barrier certificates of hybrid systems. In John Fitzgerald, Constance Heitmeyer, Stefania Gnesi, and Anna Philippou (eds.), FM 2016: Formal Methods, pp. 721–738, Cham, 2016. Springer International Publishing. ISBN 978-3-319-48989-6. ",
+        "bbox": [
+            173,
+            416,
+            825,
+            473
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yinyu Ye. Approximating quadratic programming with bound and quadratic constraints. Mathematical Programming, 84(2):219–226, Feb 1999. ISSN 1436-4646. doi: 10.1007/s10107980012a. ",
+        "bbox": [
+            174,
+            482,
+            820,
+            511
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alp Yurtsever, Olivier Fercoq, and Volkan Cevher. A conditional-gradient-based augmented lagrangian framework. In Proceedings of the 36th International Conference on Machine Learning, volume 97 of Proceedings of Machine Learning Research, pp. 7272–7281, Long Beach, California, USA, 09–15 Jun 2019. PMLR. ",
+        "bbox": [
+            174,
+            518,
+            825,
+            575
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Y. Zhang, Z. Yang, W. Lin, H. Zhu, X. Chen, and X. Li. Safety verification of nonlinear hybrid systems based on bilinear programming. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, 37(11):2768–2778, Nov 2018. doi: 10.1109/TCAD.2018.2858383. ",
+        "bbox": [
+            176,
+            585,
+            823,
+            628
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "A PROOF OF THEOREM 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            398,
+            118
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Theorem. Let $f$ be a differentiable and Lipschitz continuous function on an open, convex subset $\\mathcal { X }$ of a euclidean space. Let $\\| \\cdot \\|$ be the dual norm. The Lipschitz constant of $f$ is given by ",
+        "bbox": [
+            173,
+            133,
+            823,
+            162
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/75dfe4ce7cb4a035435f0b2e71357c5eec573e8af23660a36246e3b6a1b236ae.jpg",
+        "text": "$$\nL ( f ) = \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\nabla f ( x ) \\| _ { * }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            419,
+            169,
+            576,
+            194
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Proof. First we show that $L ( f ) \\leq \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\left\\| \\nabla f ( x ) \\right\\| _ { * }$ . ",
+        "bbox": [
+            173,
+            208,
+            532,
+            227
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/11c208c20edd3bfbe6f7541c0dcc3b8f8bd7d078186d170c8a575f6991daf8d2.jpg",
+        "text": "$$\n\\begin{array} { r l } { | f ( y ) - f ( x ) | = \\displaystyle \\left. \\int _ { 0 } ^ { 1 } \\nabla f ( ( 1 - t ) x + t y ) ^ { T } ( y - x ) d t \\right. } & { } \\\\ { \\displaystyle } & { \\le \\displaystyle \\int _ { 0 } ^ { 1 } \\left. \\nabla f ( ( 1 - t ) x + t y ) ^ { T } ( y - x ) \\right. d t } \\\\ { \\displaystyle } & { \\le \\displaystyle \\int _ { 0 } ^ { 1 } \\| \\nabla f ( ( 1 - t ) x + t y ) \\| _ { * } d t \\| y - x \\| } \\\\ { \\displaystyle } & { \\le \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\nabla f ( x ) \\| _ { * } \\| y - x \\| } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            313,
+            232,
+            681,
+            367
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "were we have used the convexity of $\\mathcal { X }$ . ",
+        "bbox": [
+            174,
+            373,
+            429,
+            388
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Now we show the reverse inequality $L ( f ) \\geq \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\nabla f ( x ) \\| _ { * }$ . To this end, we show that for any positive $\\epsilon$ , we have that $L ( f ) \\geq \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\nabla f ( x ) \\| _ { * } ^ { - } - \\epsilon$ . ",
+        "bbox": [
+            176,
+            393,
+            821,
+            425
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Let $z \\in \\mathcal { X }$ be such that $\\begin{array} { r } { \\| \\nabla f ( z ) \\| _ { * } \\geq \\operatorname* { s u p } _ { x \\in \\mathcal { X } } \\| \\nabla f ( x ) \\| _ { * } - \\epsilon } \\end{array}$ . Because $\\mathcal { X }$ is open, there exists a sequence $\\{ h _ { k } \\} _ { k = 1 } ^ { \\infty }$ with the following properties: ",
+        "bbox": [
+            171,
+            429,
+            823,
+            459
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "1. $\\langle h _ { k } , \\nabla f ( z ) \\rangle = \\| h _ { k } \\| \\| \\nabla f ( z ) \\| _ { * }$   \n2. $z + h _ { k } \\in \\mathcal { X }$   \n3. $\\scriptstyle \\operatorname* { l i m } _ { k \\to \\infty } h _ { k } = 0$ . ",
+        "bbox": [
+            210,
+            469,
+            441,
+            536
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "By definition of the gradient, there exists a function $\\delta$ such that $\\begin{array} { r } { \\operatorname* { l i m } _ { h  0 } \\delta ( h ) = 0 } \\end{array}$ and the following holds: ",
+        "bbox": [
+            173,
+            549,
+            826,
+            578
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/38ad4a9092670ba6ca44fc64a23c7fa0036502183c9ee4b5246dad401ab5b5f1.jpg",
+        "text": "$$\nf ( z + h ) = f ( z ) + \\langle h , \\nabla f ( z ) \\rangle + \\delta ( h ) \\| h \\|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            584,
+            642,
+            602
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "For our previously defined iterates $h _ { k }$ we then have ",
+        "bbox": [
+            173,
+            626,
+            513,
+            641
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f035e537b88c8260bf8fab399bdd1662362352735767530a787320483ef4834b.jpg",
+        "text": "$$\n\\Rightarrow | f ( z + h _ { k } ) - f ( z ) | = | \\| h _ { k } \\| \\| \\nabla f ( z ) \\| _ { * } + \\delta ( h _ { k } ) \\| h _ { k } \\| |\n$$",
+        "text_format": "latex",
+        "bbox": [
+            308,
+            647,
+            687,
+            665
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Dividing both sides by $\\| h _ { k } \\|$ and using the definition of $L ( f )$ we finally get ",
+        "bbox": [
+            174,
+            671,
+            668,
+            686
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "equation",
+        "img_path": "images/70b835093901ec3f851bb3421f3cd18cc33122b41478fb029605712706c281b0.jpg",
+        "text": "$$\n\\begin{array} { r l } & { \\Rightarrow L ( f ) \\geq \\left| \\frac { f ( z + h _ { k } ) - f ( z ) } { \\| h _ { k } \\| } \\right| = \\| \\| \\nabla f ( z ) \\| _ { * } + \\delta ( h _ { k } ) \\| } \\\\ & { \\Rightarrow L ( f ) \\geq \\underset { k \\to \\infty } { \\operatorname* { l i m } } \\left| \\| f ( z ) \\| _ { * } + \\delta ( h _ { k } ) \\right| = \\| \\nabla f ( z ) \\| _ { * } } \\\\ & { \\Rightarrow L ( f ) \\geq \\underset { x \\in \\mathcal { X } } { \\operatorname* { s u p } } \\| \\nabla f ( x ) \\| _ { * } - \\epsilon } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            310,
+            693,
+            684,
+            780
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "B PROOF OF PROPOSITION 1 ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            426,
+            118
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Proposition. Let $f _ { d }$ be a dense network (all weights are nonzero). The following sets, indexed by $i = 1 , \\ldots , n _ { d } ,$ form a valid sparsity pattern for the norm-gradient polynomial of the network $f _ { d }$ : ",
+        "bbox": [
+            171,
+            133,
+            825,
+            162
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/28c073681c59ded7112f85f02f38fbdcd87581ad3f5fe805743c77946d8ec9b8.jpg",
+        "text": "$$\nI _ { i } : = \\left\\{ s _ { ( d - 1 , i ) } \\right\\} \\cup \\left\\{ s _ { ( j , k ) } : t h e r e \\ e x i s t s a \\ d i r e c t e d p a t h f r o m \\ s _ { ( j , k ) } \\ t o \\ s _ { ( d - 1 , i ) } \\ i n \\ G _ { d } \\right\\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            202,
+            167,
+            766,
+            188
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Proof. First we show that $\\cup _ { i = 1 } ^ { m } I _ { i } = I$ . This comes from the fact that any neuron in the network is connected to at least one neuron in the last layer. Otherwise such neuron could be removed from the network altogether. ",
+        "bbox": [
+            173,
+            199,
+            825,
+            242
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Now we show the second property of a valid sparsity pattern. Note that the norm-gradient polynomial is composed of monomials corresponding to the product of variables in a path from input to a final neuron. This imples that if we let $p _ { i }$ be the sum of all the terms that involve the neuron $s _ { ( d - 1 , i ) }$ we have that $p = \\sum _ { i } p _ { i }$ , and $p _ { i }$ only depends on the variables in $I _ { i }$ . ",
+        "bbox": [
+            173,
+            248,
+            825,
+            308
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "We now show the last property of the valid sparsity pattern. This is the only part where we use that the network is dense. For any network architecture the first two conditions hold. We will use the fact that the maximal cliques of a chordal graph form a valid sparsity pattern (see for example Lasserre (2006)). ",
+        "bbox": [
+            174,
+            313,
+            825,
+            369
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "Because the network is dense, we see that the clique $I _ { i }$ is composed of the neuron in the last layer $s _ { ( d - 1 , i ) }$ and all neurons in the previous layers. Now consider the extension of the computational graph $\\hat { G } _ { d } = ( V , \\hat { E } )$ where ",
+        "bbox": [
+            173,
+            376,
+            825,
+            422
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "equation",
+        "img_path": "images/6d0207377aeca8d2dbfbc4e2f33b0809474cb656649321b97c0b44d62f73e483.jpg",
+        "text": "$$\n\\hat { E } = E \\cup \\{ ( s _ { j , k } , s _ { l , m } ) : j , l \\leq d - 2 ) \\}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            370,
+            430,
+            627,
+            449
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "text",
+        "text": "which consists of adding all the edges between the neurons that are not in the last layer. We show that this graph is chordal. Let $( a _ { 1 } , \\ldots , a _ { r } , a _ { 1 } )$ be a cycle of length at least 4 $( r \\geq 4 )$ ). notice that because neurons in the last layer are not connected between them in $\\hat { G }$ , no two consecutive neurons in this cycle belong to the last layer. This implies that in the subsequence $( a _ { 1 } , a _ { 2 } , a _ { 3 } , a _ { 4 } , a _ { 5 } )$ at most three belong to the last layer. A simple analysis of all cases implies that it contains at least two nonconsecutive neurons not in the last layer. Neurons not in the last layer are always connected in $\\hat { G }$ . This constitutes a chord. This shows that $\\hat { G } _ { d }$ is a chordal graph. Its maximal cliques correspond exactly to the sets in proposition. ",
+        "bbox": [
+            173,
+            454,
+            825,
+            571
+        ],
+        "page_idx": 14
+    },
+    {
+        "type": "image",
+        "img_path": "images/c4d3bde944b1201dbb14a1b15dbe0955ab341b628a0782d8b01936caadfeaf19.jpg",
+        "image_caption": [
+            "Figure 9: Lipschitz bound comparison for 1-hidden layer networks "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            137,
+            813,
+            241
+        ],
+        "page_idx": 15
+    },
+    {
+        "type": "image",
+        "img_path": "images/5b9afc5939934f50f5c505c382a417332da65ece6fd0ac90a05e2e208e5c12a0.jpg",
+        "image_caption": [
+            "Figure 10: Lipschitz bound comparison for 2-hidden layer networks "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            181,
+            286,
+            813,
+            391
+        ],
+        "page_idx": 15
+    }
+]