Add files using upload-large-folder tool

parse/train/Bk8ZcAxR-/Bk8ZcAxR-.md

@@ -0,0 +1,401 @@
+# EIGENOPTION DISCOVERY THROUGH THEDEEP SUCCESSOR REPRESENTATION
+
+Marlos C. Machado1∗, Clemens Rosenbaum2, Xiaoxiao Guo3   
+Miao Liu3, Gerald Tesauro3, Murray Campbell3   
+1 University of Alberta, Edmonton, AB, Canada   
+2 University of Massachusetts, Amherst, MA, USA   
+3 IBM Research, Yorktown Heights, NY, USA
+
+# ABSTRACT
+
+Options in reinforcement learning allow agents to hierarchically decompose a task into subtasks, having the potential to speed up learning and planning. However, autonomously learning effective sets of options is still a major challenge in the field. In this paper we focus on the recently introduced idea of using representation learning methods to guide the option discovery process. Specifically, we look at eigenoptions, options obtained from representations that encode diffusive information flow in the environment. We extend the existing algorithms for eigenoption discovery to settings with stochastic transitions and in which handcrafted features are not available. We propose an algorithm that discovers eigenoptions while learning non-linear state representations from raw pixels. It exploits recent successes in the deep reinforcement learning literature and the equivalence between proto-value functions and the successor representation. We use traditional tabular domains to provide intuition about our approach and Atari 2600 games to demonstrate its potential.
+
+# 1 INTRODUCTION
+
+Sequential decision making usually involves planning, acting, and learning about temporally extended courses of actions over different time scales. In the reinforcement learning framework, options are a well-known formalization of the notion of actions extended in time; and they have been shown to speed up learning and planning when appropriately defined (e.g., Brunskill & Li, 2014; Guo et al., 2017; Solway et al., 2014). In spite of that, autonomously identifying good options is still an open problem. This problem is known as the problem of option discovery.
+
+Option discovery has received ample attention over many years, with varied solutions being proposed (e.g., Bacon et al., 2017; S¸ imsek & Barto, 2004; Daniel et al., 2016; Florensa et al., 2017; Konidaris & Barto, 2009; Mankowitz et al., 2016; McGovern & Barto, 2001). Recently, Machado et al. (2017) and Vezhnevets et al. (2017) proposed the idea of learning options that traverse directions of a latent representation of the environment. In this paper we further explore this idea.
+
+More specifically, we focus on the concept of eigenoptions (Machado et al., 2017), options learned using a model of diffusive information flow in the environment. They have been shown to improve agents’ performance by reducing the expected number of time steps a uniform random policy needs in order to traverse the state space. Eigenoptions are defined in terms of proto-value functions (PVFs; Mahadevan, 2005), basis functions learned from the environment’s underlying state-transition graph. PVFs and eigenoptions have been defined and thoroughly evaluated in the tabular case. Currently, eigenoptions can be used in environments where it is infeasible to enumerate states only when a linear representation of these states is known beforehand.
+
+In this paper we extend the notion of eigenoptions to stochastic environments with non-enumerated states, which are commonly approximated by feature representations. Despite methods that learn representations generally being more flexible, more scalable, and often leading to better performance, current algorithms for eigenoption discovery cannot be combined with representation learning. We introduce an algorithm that is capable of discovering eigenoptions while learning representations. The learned representations implicitly approximate the model of diffusive information flow (hereafter abbreviated as the DIF model) in the environment. We do so by exploiting the equivalence between PVFs and the successor representation (SR; Dayan, 1993). Notably, by using the SR we also start to be able to deal with stochastic transitions naturally, a limitation of previous algorithms.
+
+We evaluate our algorithm in a tabular domain as well as on Atari 2600 games. We use the tabular domain to provide intuition about our algorithm and to compare it to the algorithms in the literature. Our evaluation in Atari 2600 games provides promising evidence of the applicability of our algorithm in a setting in which a representation of the agent’s observation is learned from raw pixels.
+
+# 2 BACKGROUND
+
+In this section we discuss the reinforcement learning setting, the options framework, and the set of options known as eigenoptions. We also discuss the successor representation, which is the main concept used in the proposed algorithm.
+
+# 2.1 REINFORCEMENT LEARNING AND OPTIONS
+
+We consider the reinforcement learning (RL) problem in which a learning agent interacts with an unknown environment in order to maximize a reward signal. RL is often formalized as a Markov decision process (MDP), described as a 5-tuple: $\langle \mathcal { S } , \mathcal { A } , p , r , \gamma \rangle$ . At time $t$ the agent is in state $s _ { t } \in \mathcal S$ where it takes action $a _ { t } \in \mathcal A$ that leads to the next state $s _ { t + 1 } ~ \in ~ \mathcal { S }$ according to the transition probability kernel $p ( s ^ { \prime } | s , a )$ . The agent also observes a reward $R _ { t + 1 }$ generated by the function $r : \mathcal { S } \times \mathcal { A }  \mathbb { R }$ . The agent’s goal is to learn a policy $\pi : \mathcal { S \times A } \to [ 0 , 1 ]$ that maximizes the expected discounted return $\begin{array} { r } { G _ { t } \doteq \mathbb { E } _ { \pi , p } \big [ \sum _ { k = 0 } ^ { \infty } \gamma ^ { k } R _ { t + k + 1 } | s _ { t } \big ] } \end{array}$ , where $\gamma \in [ 0 , 1 ]$ is the discount factor.
+
+In this paper we are interested in the class of algorithms that determine the agent’s policy by being greedy with respect to estimates of value functions; either w.r.t. the state value $v _ { \pi } ( s )$ , or w.r.t. the state-action value function $q _ { \pi } ( s , a )$ . Formally, $\begin{array} { r } { v _ { \pi } ( s ) = \mathbb { E } _ { \pi , p } [ G _ { t } | s ] = \sum _ { a } \pi ( a | s ) q _ { \pi } ( s , a ) } \end{array}$ . Notice that in large problems these estimates have to be approximated because it is infeasible to learn a value for each state-action pair. This is generally done by parameterizing $q _ { \pi } ( s , a )$ with a set of weights $\pmb \theta$ such that $q ( s , a , \pmb \theta ) \approx q _ { \pi } ( s , a )$ . Currently, neural networks are the most successful parametrization approach in the field (e.g., Mnih et al., 2015; Tesauro, 1995). One of the better known instantiations of this idea is the algorithm called Deep Q-network (DQN; Mnih et al., 2015), which uses a neural network to estimate state-action value functions from raw pixels.
+
+Options (Sutton et al., 1999) are our main topic of study. They are temporally extended actions that allow us to represent courses of actions. An option $\omega \in \Omega$ is a 3-tuple $\omega = \langle { \mathcal { T } } _ { \omega } , { \pi } _ { \omega } , { \mathcal { T } } _ { \omega } \rangle$ where $\mathcal { T } _ { \omega } \subseteq \mathcal { S }$ denotes the option’s initiation set, $\pi _ { \omega } : \mathcal { S } \times \mathcal { A } \to [ 0 , 1 ]$ denotes the option’s policy, and $\mathcal { T } _ { \omega } \subseteq \mathcal { S }$ denotes the option’s termination set. We consider the call-and-return option execution model in which a meta-policy $\mu : \mathcal { S }  \Omega$ dictates the agent’s behavior (notice ${ \mathcal { A } } \subseteq \Omega$ ). After the agent decides to follow option $\omega$ from a state in $\mathcal { T } _ { \omega }$ , actions are selected according to $\pi _ { \omega }$ until the agent reaches a state in $\mathcal { T } _ { \omega }$ . We are interested in learning $\mathcal { T } _ { \omega } , \pi _ { \omega }$ , and $\mathcal { T } _ { \omega }$ from scratch.
+
+# 2.2 PROTO-VALUE FUNCTIONS AND EIGENOPTIONS
+
+Eigenoptions are options that maximize eigenpurposes $r _ { i } ^ { \mathbf { e } }$ , intrinsic reward functions obtained from the DIF model (Machado et al., 2017). Formally,
+
+$$
+\begin{array} { r l r } { r _ { i } ^ { \bf e } ( s , s ^ { \prime } ) } & { { } = } & { { \bf e } ^ { \top } \Big ( \phi ( s ^ { \prime } ) - \phi ( s ) \Big ) , } \end{array}
+$$
+
+where $\phi ( \cdot )$ denotes a feature representation of a given state (e.g., one-hot encoding in the tabular case) and e denotes an eigenvector encoding the DIF model at a specific timescale. Each intrinsic reward function, defined by the eigenvector being used, incentivizes the agent to traverse a different latent dimension of the state space.
+
+In the tabular case, the algorithms capable of learning eigenoptions encode the DIF model through the combinatorial graph Laplacian $\bar { \mathcal { L } } = D ^ { - 1 / 2 } ( D \bar { - } \bar { W } ) D ^ { \bar { - } 1 / 2 }$ , where $W$ is the graph’s weight matrix and $D$ is the diagonal matrix whose entries are the row sums of $W$ . The weight matrix is a square matrix where the $i j$ -th entry represents the connection between states $i$ and $j$ . Notice that this approach does not naturally deal with stochastic or unidirectional transitions because $W$ is generally defined as a symmetric adjacency matrix. Importantly, the eigenvectors of $\mathcal { L }$ are also known as proto-value functions (PVFs; Mahadevan, 2005; Mahadevan & Maggioni, 2007).
+
+![](images/a503f92cdcf23be0fa4aae70361622e445f8baf09e44e653899cb98af3f85a38.jpg)  
+Figure 1: Successor representation, with respect to the uniform random policy, of state A (left). This example is similar to Dayan’s (1993). The red color represents larger values while the blue color represents smaller values (states that are temporally further away).
+
+In settings in which states cannot be enumerated, the DIF model is represented through a matrix of transitions $T$ , with row $i$ encoding the transition vector $\phi ( s _ { t } ) - \phi ( \bar { s } _ { t - 1 } )$ , where $\phi ( \cdot )$ denotes a fixed linear feature representation known beforehand ( $i$ can be different from $t$ if transitions are observed more than once). Machado et al. (2017) justifies this sampling strategy with the fact that, in the tabular case, if every transition is sampled once, the right eigenvectors of matrix $T$ converge to PVFs. Because transitions are added only once, regardless of their frequency, this algorithm is not well suited to stochastic environments. In this paper we introduce an algorithm that naturally deals with stochasticity and that does not require $\phi ( \cdot )$ to be known beforehand. Our algorithm learns the environment’s DIF model while learning a representation of the environment from raw pixels.
+
+# 2.3 THE SUCCESSOR REPRESENTATION
+
+The successor representation (SR; Dayan, 1993) determines state generalization by how similar its successor states are. It is defined to be the expected future occupancy of state $s ^ { \prime }$ given the agent’s policy is $\pi$ and its starting state is $s$ . It can be seen as defining state similarity in terms of time. See Figure 1 for an example. The Euclidean distance between state A and state C is smaller than the Euclidean distance between state A and state B. However, if one considers the gray tiles to be walls, an agent in state A can reach state B much quicker than state C. The SR captures this distinction, ensuring that state A is more similar to state $\mathbf { B }$ than it is to state C.
+
+Let $\mathbb { 1 } _ { \{ \cdot \} }$ denote the indicator function, the SR, $\Psi _ { \pi } ( s , s ^ { \prime } )$ , is formally defined, for $\gamma < 1$ , as :
+
+$$
+\begin{array} { r l l } { \Psi _ { \pi } ( s , s ^ { \prime } ) } & { = } & { \mathbb { E } _ { \pi , p } \Bigg [ \displaystyle \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \mathbb { 1 } _ { \{ S _ { t } = s ^ { \prime } \} } \Big | S _ { 0 } = s \Bigg ] . } \end{array}
+$$
+
+This expectation can be estimated from samples with temporal-difference error (Sutton, 1988):
+
+$$
+\begin{array} { r l r } { \hat { \Psi } ( s , j ) } & { \longleftarrow } & { \hat { \Psi } ( s , j ) + \eta \Biggl [ \mathbb { 1 } _ { \{ s = j \} } + \gamma \hat { \Psi } ( s ^ { \prime } , j ) - \hat { \Psi } ( s , j ) \Biggr ] , } \end{array}
+$$
+
+where $\eta$ is the step-size. In the limit, the SR converges to $\Psi _ { \pi } = ( I { - } \gamma T _ { \pi } ) ^ { - 1 }$ . This lets us decompose the value function into the product between the SR and the immediate reward (Dayan, 1993):
+
+$$
+v _ { \pi } ( s ) = \sum _ { s ^ { \prime } \in S } \Psi _ { \pi } ( s , s ^ { \prime } ) r ( s ^ { \prime } ) .
+$$
+
+The SR is directly related to several other ideas in the field. It can be seen as the dual approach to dynamic programming and to value-function based methods in reinforcement learning (Wang et al., 2007). Moreover, the eigenvectors generated from its eigendecomposition are equivalent to proto-value functions (Stachenfeld et al., 2014; 2017) and to slow feature analysis (Sprekeler, 2011).
+
+Alg. 1 Eigenoption discovery through the SR   
+
+<table><tr><td>←LEARNREPRESENTATION() E←EXTRACTEIGENPURPOSES(亚)</td></tr><tr><td>for each eigepurpose ei ∈Edo</td></tr><tr><td>{Ie;,Te,Te&gt;←LEARNEIGENOPTION(ei)</td></tr><tr><td>end for</td></tr></table>
+
+Alg. 2 LEARNREPRESENTATION() with the SR   
+
+<table><tr><td>fora given number of steps n do Observes ∈S,take action α ∈A selected ac- cording to π(s),and observe a next state s&#x27; ∈ S for each state j ∈ S do</td></tr><tr><td>重（s,j)←(s,j)+ n(l{s=j}+γ亚(s&#x27;,j）-Φ(s,j))</td></tr><tr><td>end for</td></tr><tr><td>end for return 业</td></tr></table>
+
+Such equivalences play a central role in the algorithm we describe in the next section. The SR may also have an important role in neuroscience. Stachenfeld et al. (2014; 2017) recently suggested that the successor representation is encoded by the hippocampus, and that a low-dimensional basis set representing it is encoded by the enthorhinal cortex. Interestingly, both hippocampus and entorhinal cortex are believed to be part of the brain system responsible for spatial memory and navigation.
+
+# 3 EIGENOPTION DISCOVERY
+
+In order to discover eigenoptions, we first need to obtain the eigenpurposes through the eigenvectors encoding the DIF model in the environment. This is currently done through PVFs, which the agent obtains by either explicitly building the environment’s adjacency matrix or by enumerating all of the environment’s transitions $\cdot f .$ Section 2.2). Such an approach is fairly effective in deterministic settings in which states can be enumerated and uniquely identified, i.e., the tabular case. However, there is no obvious extension of this approach to stochastic settings. It may be hard for the agent to explicitly model the environment dynamics in a weight matrix. The existent alternative, to enumerate the environment’s transitions, may have a large cost. These issues become worse when states cannot be enumerated, i.e., the function approximation case. The existing algorithm that is applicable to the function approximation setting requires a fixed representation as input, not being able to learn a representation while estimating the DIF model.
+
+In this paper we introduce an algorithm that addresses the aforementioned issues by estimating the DIF model through the SR. Also, we introduce a new neural network that is capable of approximating the SR from raw pixels by learning a latent representation of game screens. The learned SR is then used to discover eigenoptions, replacing the need for knowing the combinatorial Laplacian. In this section we discuss the proposed algorithm in the tabular case, the equivalence between PVFs and the SR, and the algorithm capable of estimating the SR, and eigenoptions, from raw pixels.
+
+# 3.1 THE TABULAR CASE
+
+The general structure of the algorithms capable of discovering eigenoptions is fairly straightforward, as shown in Alg. 1. The agent learns (or is given) a representation that captures the DIF model (e.g., the combinatorial Laplacian). It then uses the eigenvectors of this representation to define eigenpurposes (EXTRACTEIGENPURPOSES), the intrinsic reward functions described by Equation 1 that it will learn how to maximize. The option’s policy is the one that maximizes this new reward function, while a state $s$ is defined to be terminal with respect to the eigenpurpose $\mathbf { e } _ { i }$ if $q _ { * } ^ { \mathbf { e } _ { i } } ( s , a ) \leq 0$ for all $a \in { \mathcal { A } }$ . The initiation set of an option $\mathbf { e } _ { i }$ is defined to be $\mathcal { S } \setminus \mathcal { T } _ { { \mathbf { e } } _ { i } } ^ { \overline { { \mathbf { \Theta } } } }$ .
+
+In the tabular case, our proposed algorithm is also fairly simple. Instead of assuming the matrix $\hat { \Psi }$ is given in the form of the graph Laplacian, or trying to estimate the graph Laplacian from samples by stacking the row vectors corresponding to the different observed transitions, we estimate the DIF model through the successor representation $\left( c . f . \right.$ Alg. 2). This idea is supported by the fact that, for our purposes, the eigenvectors of the normalized Laplacian and the eigenvectors of the SR are equivalent. Below we formalize this concept and discuss its implications. We show that the eigenvectors of the normalized Laplacian are equal to the eigenvectors of the SR scaled by $\gamma ^ { - 1 } D ^ { 1 / 2 }$ .
+
+The aforementioned equivalence ensures that the eigenpurposes extraction and the eigenoption learning steps remain unchanged. That is, we still obtain the eigenpurposes from the eigendecomposition1 of matrix $\hat { \Psi }$ , and we still use each eigenvector $\mathbf { e } _ { i } \in E$ to define the new learning problem in which the agent wants to maximize the eigenpurpose, defined in Equation 1.
+
+Importantly, the use of the SR addresses some other limitations of previous work: 1) it deals with stochasticity in the environment and in the agent’s policy naturally; 2) its memory cost is independent on the number of samples drawn by the agent; and 3) it does not assume that for every action there is another action the agent can take to return to the state it was before, i.e., $W$ is symmetric.
+
+# 3.2 RELATIONSHIP BETWEEN PVFS AND THE SR
+
+As aforementioned, PVFs (the eigenvectors of the normalized Laplacian) are equal to the eigenvectors of the successor representation scaled by $\gamma ^ { - 1 } D ^ { 1 / 2 }$ . To the best of our knowledge, this equivalence was first explicitly discussed by Stachenfeld et al. (2014). We provide below a more formal statement of such an equivalence, for the eingevalues and the eigenvectors of both approaches. We use the proof to further discuss the extent of this interchangeability.
+
+Theorem. Stachenfeld et al. (2014): Let $0 < \gamma < 1$ s.t. $\Psi = ( I - \gamma T ) ^ { - 1 }$ denotes the matrix encoding the $S R$ , and let $\mathcal { L } = D ^ { - 1 / 2 } ( D - W ) D ^ { - 1 / 2 }$ denote the matrix corresponding to the normalized Laplacian, both obtained under a uniform random policy. The $i$ -th eigenvalue $( \lambda _ { S R , i } )$ of the SR and the $j$ -th eigenvalue $( \lambda _ { P V F , j } )$ of the normalized Laplacian are related as follows:
+
+$$
+\lambda _ { P V F , j } = \left[ 1 - ( 1 - { \lambda _ { S R , i } } ^ { - 1 } ) \gamma ^ { - 1 } \right]
+$$
+
+The $i$ -th eigenvector $( \mathbf { e } _ { S R , i } )$ of the $S R$ and the $j$ -th eigenvector $( \mathbf { e } _ { P V F , j } )$ of the normalized Laplacian, where $i + j = n + 1$ , with $n$ being the total number of rows (and columns) of matrix $T$ , are related as follows:
+
+$$
+{ \bf e } _ { P V F , j } = ( \gamma ^ { - 1 } D ^ { 1 / 2 } ) { \bf e } _ { S R , i }
+$$
+
+Proof. Let $\lambda _ { i }$ , $\mathbf { e } _ { i }$ denote the $i$ -th eigenvalue and eigenvector of the SR, respectively. Using the fact that the SR is known to converge, in the limit, to $( I { \bar { - } } \gamma T ) ^ { - 1 }$ (through the Neumann series), we have:
+
+$$
+\begin{array} { r l } { { ( I - \gamma T ) ^ { - 1 } { \bf e } _ { i } ~ = ~ \lambda _ { i } { \bf e } _ { i } } } & { { } } \\ { { ( I - \gamma T ) { \bf e } _ { i } ~ = ~ \lambda _ { i } ^ { - 1 } { \bf e } _ { i } } } & { { } } \\ { { ( I - T ) \gamma ^ { - 1 } { \bf e } _ { i } ~ = ~ [ 1 - ( 1 - \lambda _ { i } ^ { - 1 } ) \gamma ^ { - 1 } ] \gamma ^ { - 1 } { \bf e } _ { i } } } & { { } } \\ { { ( I - T ) \gamma ^ { - 1 } { \bf e } _ { i } ~ = ~ \lambda _ { j } ^ { \prime } \gamma ^ { - 1 } { \bf e } _ { i } } } & { { } } \\ { { ( I - D ^ { - 1 } W ) \gamma ^ { - 1 } { \bf e } _ { i } ~ = ~ \lambda _ { j } ^ { \prime } \gamma ^ { - 1 } { \bf e } _ { i } } } & { { } } \\ { { { \cal D } ^ { - 1 / 2 } ( D - W ) D ^ { - 1 / 2 } D ^ { 1 / 2 } \gamma ^ { - 1 } { \bf e } _ { i } ~ = ~ \lambda _ { j } ^ { \prime } \gamma ^ { - 1 } D ^ { 1 / 2 } { \bf e } _ { i } } } & { { } } \end{array}
+$$
+
+Importantly, when using PVFs we are first interested in the eigenvectors with the corresponding smallest eigenvalues, as they are the “smoothest” ones. However, when using the SR we are interested in the eigenvectors with the largest eigenvalues. The change of variables in Eq. 3 highlights this fact i.e., $\lambda _ { j } ^ { \overline { { \prime } } } = [ 1 - ( 1 - \lambda _ { i } ^ { - 1 } ) \gamma ^ { - 1 } ]$ . The indices $j$ are sorted in the reverse order of the indices $i$ . This distinction can be very important when trying to estimate the relevant eigenvectors. Finding the largest eigenvalues/eigenvectors is statistically more robust to noise in estimation and does not depend on the lowest spectrum of the matrix. Moreover, notice that the scaling by $D ^ { 1 / 2 }$ does not change the direction of the eigenvectors when the size of the action set is constant across all states. This is often the case in the RL problems being studied.
+
+3.3 THE FUNCTION APPROXIMATION CASE: THE SR THROUGH DEEP NEURAL NETWORKS
+
+The tabular case is interesting to study because it provides intuition about the problem and it is easier to analyze, both empirically and theoretically. However, the tabular case is only realizable in toy domains. In real-world situations the number of states is often very large and the ability to generalize and to recognize similar states is essential. In this section, inspired by Kulkarni et al.’s (2016b) and Oh et al.’s (2015) work, we propose replacing Alg. 2 by a neural network that is able to estimate the successor representation from raw pixels. Such an approach circumvents the limitations of previous work that required a linear feature representation to be provided beforehand.
+
+![](images/9759cd457503f5e7a5dd6f958661be6cb2dd23526d44cfe4f8bcc86d74b3d1d4.jpg)  
+Figure 2: Neural network architecture used to learn the SR. The symbols $\otimes$ and $\varnothing$ denote elementwise multiplication and the fact that gradients are not propagated further back, respectively.
+
+The SR with non-enumerated states: Originally, the SR was not defined in the function approximation setting, where states are described in terms of feature vectors. Successor features are the natural extension of the SR to this setting. We use Barreto et al.’s (2017) definition of successor features, where $\psi _ { \pi , i } ( s )$ denotes the successor feature $i$ of state $s \in \mathcal { S }$ when following a policy $\pi$ :
+
+$$
+\begin{array} { r c l } { \psi _ { \pi , i } ( s ) } & { = } & { \mathbb { E } _ { \pi , p } \Bigg [ \displaystyle \sum _ { t = 0 } ^ { \infty } \gamma ^ { t } \phi _ { i } ( S _ { t } ) \Big | S _ { 0 } = s \Bigg ] . } \end{array}
+$$
+
+In words, $\psi _ { \pi , i } ( s )$ encodes the discounted expected value of the $i$ -th feature in the vector $\phi ( \cdot )$ when the agent starts in state $s$ and follows the policy $\pi$ . The update rule presented in Eq. 2 can be naturally extended to this definition. The temporal-difference error in the update rule can be used as a differentiable loss function, allowing us to estimate the successor features with a neural network.
+
+Neural network architecture: The architecture we used is depicted in Fig 2. The reconstruction module is the same as the one introduced by Oh et al. (2015), but augmented by the SR estimator (the three layers depicted at the bottom). The SR estimator uses the learned latent representation as input i.e., the output of the representation learning module.
+
+The proposed neural network receives raw pixels as input and learns to estimate the successor features of a lower-dimension representation learned by the neural network. The loss function $\mathcal { L } _ { S R }$ we use to learn the successor features is:
+
+$$
+\mathcal { L } _ { S R } ( s , s ^ { \prime } ) = \mathbb { E } \Bigg [ \Big ( \phi ^ { - } ( s ) + \gamma \psi ^ { - } \left( \phi ^ { - } ( s ^ { \prime } ) \right) - \psi \left( \phi ( s ) \right) \Big ) ^ { 2 } \Bigg ] ,
+$$
+
+where $\phi ( s )$ denotes the feature vector encoding the learned representation of state $s$ and $\psi ( \cdot )$ denotes the estimated successor features. In practice, $\phi ( \cdot )$ is the output of the representation learning module and $\psi ( \cdot )$ is the output of the SR estimator, as shown in Fig. 2. The loss function above also highlights the fact that we have two neural networks. We use $-$ to represent a target network (Mnih et al., 2015), which is updated at a slower rate for stability purposes.
+
+We cannot directly estimate the successor features from raw pixels using only $\mathcal { L } _ { S R }$ because zero is one of its fixed points. This is the reason we added Oh et al.’s (2015) reconstruction module in the proposed network. It behaves as an auxiliary task (Jaderberg et al., 2017) that predicts the next state to be observed given the current state and action. By predicting the next state we increase the likelihood the agent will learn a representation that takes into consideration the pixels that are under its control, which has been shown to be a good bias in RL problems (Bellemare et al., 2012). Such an auxiliary task is defined through the network’s reconstruction error $\mathcal { L } _ { R E }$ :
+
+$$
+\begin{array} { r } { \mathcal { L } _ { R E } ( s , a , s ^ { \prime } ) = \Big ( \zeta \big ( \phi ( s ) , a \big ) - s ^ { \prime } \Big ) ^ { 2 } , } \end{array}
+$$
+
+where $\zeta ( \cdot )$ denotes the output of the reconstruction module, as shown in Fig. 2. The final loss being optimized is $\begin{array} { r } { \mathcal { L } ( s , a , s ^ { \prime } ) = \bar { \mathcal L } _ { R E } ( s , a , s ^ { \prime } ) + \mathcal { L } _ { S R } ( s , s ^ { \prime } ) } \end{array}$ .
+
+![](images/382429da21647d9e7edf513d5a0be13351292dca240c7f2fe41334f9ca711b57.jpg)  
+Figure 3: Results in the rooms domain. The rightmost figure depicts the diffusion time as eigenoptions are added to the agent’s action set (sorted by eigenvalues corresponding to the eigenpurposes).
+
+Finally, to ensure that the SR will not interfere with the learned features, we zero the gradients coming from the SR estimator (represented with the symbol $\phi$ in Fig. 2). We trained our model with RMSProp and we followed the same protocol Oh et al. (2015) used to initialize the network.
+
+Eigenoption learning: In Alg. 1, the function EXTRACTEIGENPURPOSES returns the eigenpurposes described by Eq. 1. Eigenpurposes are defined in terms of a feature representation $\phi ( s _ { t } )$ of the environment and of the eigenvectors $\mathbf { e } _ { i }$ of the DIF model (the SR in our case). We use the trained network to generate both. It is trivial to obtain $\phi ( s _ { t } )$ as we just use the output of the appropriate layer in the network as our feature representation. To obtain $\mathbf { e } _ { i }$ we first need to generate a meaningful matrix since our network outputs a vector of successor features instead of a matrix. We do so by having the agent follow the uniform random policy while we store the network outputs $\psi ( s _ { t } )$ , which correspond to the network estimate of the successor features of state $s _ { t }$ . We then create a matrix $T$ where row $t$ corresponds to $\psi ( s _ { t } )$ and we define $\mathbf { e } _ { i }$ to be its right eigenvectors.
+
+Once we have created the eigenpurposes, the option discovery problem is reduced to a regular RL problem where the agent aims to maximize the cumulative sum of rewards. Any learning algorithm can be used for that. We provide details about our approach in the next section.
+
+# 4 EXPERIMENTS
+
+We evaluate the discovered eigenoptions quantitatively and qualitatively in this section. We use the traditional rooms domain to evaluate the impact, on the eigenvectors and on the discovered options, of approximating the DIF model through the SR. We then use Atari 2600 games to demonstrate how the proposed network does discover purposeful options from raw pixels.
+
+# 4.1 TABULAR CASE
+
+Our first experiment evaluates the impact of estimating the SR from samples instead of assuming the DIF model was given in the form of the normalized Laplacian. We use the rooms domain (Fig. 3a; Sutton et al., 1999) to evaluate our method. Fig. 4b depicts the first eigenvector obtained from the SR while Fig. 4c depicts the corresponding eigenoption. We followed the uniform random policy for 1,000 episodes to learn the SR. Episodes were 100 time steps long. We used a stepsize of 0.1, and we set $\gamma = 0 . 9$ . The estimated eigenvector is fairly close to the true one and, as expected, the obtained eigenvector is fairly similar to the PVFs that are obtained for this domain. In the Appendix we provide the plots for the true SR and the PVF, as well as plots for different eigenvectors, comparing them to those obtained from $( I - \gamma T ) ^ { - 1 }$ .
+
+Eigenoptions are known for improving the agent’s ability to explore the environment. We use the metric diffusion time to validate whether such an ability is preserved with our method. The diffusion time can be seen as a proxy for how hard it is for an agent to reach the goal state when following a uniform random policy. It is defined as the expected number of decisions (action selection steps) an agent needs to take, when following the uniform random policy, to navigate between two randomly chosen states. We compared the agent’s diffusion time when using eigenoptions obtained with PVFs to the diffusion time when using eigenoptions obtained with estimates of the SR. As we can see in Fig 3d, the eigenoptions obtained with the SR do help the agent to explore the environment. The gap between the diffusion time when using PVFs and when using the SR is likely due to different ways of dealing with corners. The SR implicitly models self-loops in the states adjacent to walls, since the agent takes an action and it observes it did not move.
+
+![](images/8942a019474d6f7767a2ecce98d29255676c0573e47eb4a48731605a931cd20a.jpg)  
+Figure 4: Different environments (varying start and goal locations) used in our evaluation (a), as well as the learning curves obtained in each one of these environments (b, c) for different number of options obtained from the SR when estimated after 100 episodes. See text for more details.
+
+We also evaluated how the estimates of the SR evolve as more episodes are used during learning, and its impact in the diffusion time (Fig 3d). In the Appendix we present more results, showing that the local structure of the graph is generally preserved. Naturally, more episodes allow us to learn more accurate estimates of the SR as a more global facet of the environment is seen, since the agent has more chances to further explore the state space. However, it seems that even the SR learned from few episodes allow us to discover useful eigenoptions, as depicted in Fig. 3d. The eigenoptions obtained from the SR learned using only 100 episodes are already capable of reducing the agent’s diffusion time considerably. Finally, it is important to stress that the discovered options do more than randomly selecting subgoal states. “Random options” only reduce the agent’s diffusion time when hundreds of them are added to the agent’s action set (Machado et al., 2017).
+
+Finally, we evaluated the use of the discovered eigenoptions to maximize reward. In our experiments the agent learned, off-policy, the greedy policy over primitive actions (target policy) while following the uniform random policy over actions and eigenoptions (behavior policy). We used Qlearning (Watkins & Dayan, 1992) in our experiments – parameters $\lambda = 0$ , $\alpha = 0 . 1$ , and $\gamma = 0 . 9$ . As before, episodes were 100 time steps long. Figure 4 summarizes the obtained results comparing the performance of our approach to regular Q-learning over primitive actions. The eigenoptions were extracted from estimates of the SR obtained after 100 episodes. The reported results are the average over 24 independent runs when learning the SR, with each one of these runs encoding 100 runs evaluating Q-Learning. The options were added following the sorting provided by the eigenvalues. For example, 4 options denotes an agent with the action set used in the behavior policy being composed of the four primitive actions and the four eigenoptions generated by the top 2 eigenvalues (both directions are being used). Notice that these results do not try to take the sample efficiency of our approach into consideration, they are only meant to showcase how eigenoptions, once discovered, can speed up learning. The sample complexity of learning options is generally justified in lifelong learning settings where they are re-used over multiple tasks (e.g., Brunskill & Li, 2014). This is beyond the scope of this paper.
+
+The obtained results clearly show that eigenoptions are not only capable of reducing the diffusion time in the environment but of also improving the agent’s control performance. They do so by increasing the likelihood that the agent will cover a larger part of the state space given the same amount of time. Moreover, as before, it seems that a very accurate estimate of the successor representation is not necessary for the eigenoptions to be useful. Similar results can be obtained for different locations of the start and goal states, and when the estimates of the SR are more accurate. These results can be seen in the Appendix.
+
+# 4.2 ATARI 2600
+
+This second set of experiments evaluates the eigenoptions discovered when the SR is obtained from raw pixels. We obtained the SR through the neural network described in Section 3. We used four
+
+![](images/a16f2079363652b8d9f2a9b8ff6840e14223754c14d3dde11504659776e10590.jpg)  
+Figure 5: Plots of density of state visitation of eigenoptions discovered in three Atari 2600 games. States visited more frequently show darker images of the avatar. Note that an eigenoption’s overwhelming mass of visitations corresponds to its terminal state, and that disparate options have different terminal states.
+
+Atari 2600 games from the Arcade Learning Environment (Bellemare et al., 2013) as testbed: BANK HEIST, FREEWAY, MONTEZUMA’S REVENGE, and MS. PAC-MAN.
+
+We followed the protocol described in the previous section to create eigenpurposes. We trained the network in Fig. 2 to estimate the SR under the uniform random policy. Since the network does not impact the policy being followed, we built a dataset of 500, 000 samples for each game and we used this dataset to optimize the network weights. We passed through the shuffled dataset 10 times, using RMSProp with a step size of $1 0 ^ { - 4 }$ . Once we were done with the training, we let the agent follow a uniform random policy for $5 0 , 0 0 0$ steps while we stored the SR output by the network for each observed state as a row of matrix $T$ . We define e, in the eigenpurposes we maximize $\cdot \cdot f .$ , Eq. 1), to be the right eigenvectors of the matrix $T$ , while $\phi ( \cdot )$ is extracted at each time step from the network in Fig. 2. Due to computational constraints, we approximated the final eigenoptions. We did so by using the ALE’s internal emulator to do a one-step lookahead and act greedily with respect to each eigenpurpose (in practice, this is equivalent to learning with $\gamma = 0$ ). This is not ideal because the options we obtain are quite limited, since they do not deal with delayed rewards. However, even in such limiting setting we were able to obtain promising results, as we discuss below.
+
+Following Machado et al. (2017), we evaluate the discovered eigenoptions qualitatively. We execute all options following the procedure described above (greedy one-step lookahead) while tracking the avatar’s position on the screen. Figure 5 summarizes the behavior of some of the meaningful options discovered. The trajectories generated by different options are represented by different colors and the color’s intensity at a given location represents how often the agent was at that location. Eigenoptions were introduced as options that generate purposeful behavior and that help agents explore the environment. We can clearly see that the discovered eigenoptions are indeed purposeful. They aim to reach a specific location and stay there. If this was not the case the agent’s trajectory would be much more visible. Instead, what we actually observe is that the mass of visitation is concentrated on one location on the screen, dominating (color intensity) all the others. The location the agent is spending most of its time on can in fact be seen as the option’s terminal state. Constantly being in a state suggests the agent has arrived to a myopic local maximum for that eigenpurpose.
+
+In three out of four games (BANK HEIST, MONTEZUMA’S REVENGE, MS. PACMAN) our algorithm discovers options that clearly push the agent to corners and to other relevant parts of the state space, corroborating the intuition that eigenoptions also improve exploration. In MONTEZUMA’S REVENGE, the terminal state of the highlighted options even correspond to what are considered good subgoals for the game (Kulkarni et al., 2016a). It is likely that additional subgoals, such as the key, were not found due to our myopic greedy approach. This approach may also explain why our algorithm was ineffective in FREEWAY. Avoiding cars may be impossible without longer-term planning. A plot depicting the two meaningful options discovered in this game is in the Appendix. Importantly, the fact that myopic policies are able to navigate to specific locations and stay there also suggests that, as in the tabular case, the proposed approach gives rise to dense intrinsic rewards that are very informative. This is another important constrast between randomly assigned subgoals and our approach. Randomly assigned subgoals do not give rise to such dense rewards. Thus, one can argue that our approach does not only generate useful options but it also gives rise to dense eigenpurposes, making it easier to build the policies associated with them.
+
+It is important to stress that our algorithm was able to discover eigenoptions, from raw pixels, similar to those obtained by algorithms that use the RAM state of the game as a feature representation. The RAM state of the game often uses specific bytes to encode important information of the game, such as the position of the player’s avatar in the game. Our algorithm had to implicitly learn what were the meaningful parts of the screen. Also, different from previous algorithms, our approach is not constrained by the dimensionality of the state representation nor to binary features. Based on this discussion, we consider our results to be very promising, even though we only depict options that have effect on the initial state of the games. We believe that in a more general setting (e.g., using DQN to learn policies) our algorithm has the potential to discover even better options.
+
+# 5 RELATED WORK
+
+Our work was directly inspired by Kulkarni et al. (2016b), the first to propose approximating the SR using a neural network. We use their loss function in a novel architecture. Because we are not directly using the SR for control, we define the SR in terms of states, instead of state-action pairs. Different from Kulkarni et al. (2016b), our network does not learn a reward model and it does not use an autoencoder to learn a representation of the world. It tries to predict the next state the agent will observe. The prediction module we used was introduced by Oh et al. (2015). Because it predicts the next state, it implicitly learns representations that take into consideration the parts of the screen that are under the agent’s control. The ability to recognize such features is known as contingency awareness, and it is known to have the potential to improve agents’ performance (Bellemare et al., 2012). Kulkarni et al. (2016b) did suggest the deep SR could be used to find bottleneck states, which are commonly used as subgoals for options, but such an idea was not further explored. Importantly, Jong et al. (2008) and Machado et al. (2017) have shown that options that look for bottleneck states can be quite harmful in the learning process.
+
+The idea of explicitly building hierarchies based on the learned latent representation of the state space is due to Machado et al. (2017) and Vezhnevets et al. (2017). Machado et al. (2017) proposed the concept of eigenoptions, but limited to the linear function approximation case. Vezhnevets et al. (2017) do not explicitly build options with initiation and termination sets. Instead, they learn a hierarchy through an end-to-end learning system that does not allow us to easily retrieve options from it. Finally, Kompella et al. (2017) has proposed the use of slow feature analysis (SFA; Wiskott & Sejnowski, 2002) to discover options. Sprekeler (2011) has shown that, given a specific choice of adjacency function, PVFs (and consequently the SR) are equivalent to SFA. However, their work is limited to linear function approximation. Our method also differs in how we define the initiation and termination sets. The options they discover look for bottleneck states, which is not our case.
+
+# 6 CONCLUSION
+
+In this paper we introduced a new algorithm for eigenoption discovery in RL. Our algorithm uses the successor representation (SR) to estimate the model of diffusive information flow in the environment, leveraging the equivalence between proto-value functions (PVFs) and the SR. This approach circumvents several limitations from previous work: (i) it builds increasingly accurate estimates using a constant-cost update-rule; (ii) it naturally deals with stochastic MDPs; (iii) it does not depend on the assumption that the transition matrix is symmetric; and (iv) it does not depend on handcrafted feature representations. The first three items were achieved by simply using the SR instead of the PVFs, while the latter was achieved by using a neural network to estimate the SR.
+
+The proposed framework opens up multiple possibilities for investigation in the future. It would be interesting to evaluate the compositionality of eigenoptions, or how transferable they are between similar environments, such as the different modes of Atari 2600 games (Machado et al., 2018). Finally, now that the fundamental algorithms have been introduced, it would be interesting to investigate whether one can use eigenoptions to accumulate rewards instead of using them for exploration.
+
+# ACKNOWLEDGMENTS
+
+The authors would like to thank Craig Sherstan and Martha White for feedback on an earlier draft, Kamyar Azizzadenesheli, Marc G. Bellemare and Michael Bowling for useful discussions, and the anonymous reviewers for their feedback and suggestions.
+
+# REFERENCES
+
+Pierre-Luc Bacon, Jean Harb, and Doina Precup. The Option-Critic Architecture. In Proc. of the AAAI Conference on Artificial Intelligence (AAAI), pp. 1726–1734, 2017.
+
+Andre Barreto, Will Dabney, R ´ emi Munos, Jonathan Hunt, Tom Schaul, David Silver, and Hado ´ van Hasselt. Successor Features for Transfer in Reinforcement Learning. In Advances in Neural Information Processing Systems (NIPS), pp. 4058–4068, 2017.
+
+Marc G. Bellemare, Joel Veness, and Michael Bowling. Investigating Contingency Awareness Using Atari 2600 Games. In Proc. of the AAAI Conference on Artificial Intelligence (AAAI), 2012.
+
+Marc G. Bellemare, Yavar Naddaf, Joel Veness, and Michael Bowling. The Arcade Learning Environment: An Evaluation Platform for General Agents. Journal of Artificial Intelligence Research, 47:253–279, 2013.
+
+Emma Brunskill and Lihong Li. PAC-inspired Option Discovery in Lifelong Reinforcement Learning. In Proc. of the International Conference on Machine Learning (ICML), pp. 316–324, 2014.
+
+Ozg ¨ ur S¸ imsek and Andrew G. Barto. Using Relative Novelty to Identify Useful Temporal Abstrac- ¨ tions in Reinforcement Learning. In Proc. of the International Conference on Machine Learning (ICML), 2004.
+
+Christian Daniel, Herke van Hoof, Jan Peters, and Gerhard Neumann. Probabilistic Inference for Determining Options in Reinforcement Learning. Machine Learning, 104(2-3):337–357, 2016.
+
+Peter Dayan. Improving Generalization for Temporal Difference Learning: The Successor Representation. Neural Computation, 5(4):613–624, 1993.
+
+Carlos Florensa, Yan Duan, and Pieter Abbeel. Stochastic Neural Networks for Hierarchical Reinforcement Learning. In Proc. of the International Conference on Learning Representations (ICLR), 2017.
+
+Zhaohan Daniel Guo, Philip S. Thomas, and Emma Brunskill. Using Options and Covariance Testing for Long Horizon Off-Policy Policy Evaluation. In Advances in Neural Information Processing Systems (NIPS), pp. 2489–2498, 2017.
+
+Max Jaderberg, Volodymyr Mnih, Wojciech Marian Czarnecki, Tom Schaul, Joel Z. Leibo, David Silver, and Koray Kavukcuoglu. Reinforcement Learning with Unsupervised Auxiliary Tasks. In Proc. of the International Conference on Learning Representations (ICLR), 2017.
+
+Nicholas K. Jong, Todd Hester, and Peter Stone. The Utility of Temporal Abstraction in Reinforcement Learning. In Proc. of the International Joint Conference on Autonomous Agents and Multiagent Systems (AAMAS), pp. 299–306, 2008.
+
+Varun Raj Kompella, Marijn F. Stollenga, Matthew D. Luciw, and Jurgen Schmidhuber. Continual ¨ Curiosity-driven Skill Acquisition from High-Dimensional Video Inputs for Humanoid Robots. Artificial Intelligence, 247:313–335, 2017.
+
+George Konidaris and Andrew G. Barto. Skill Discovery in Continuous Reinforcement Learning Domains using Skill Chaining. In Advances in Neural Information Processing Systems (NIPS), pp. 1015–1023, 2009.
+
+Tejas D. Kulkarni, Karthik Narasimhan, Ardavan Saeedi, and Josh Tenenbaum. Hierarchical Deep Reinforcement Learning: Integrating Temporal Abstraction and Intrinsic Motivation. In Advances in Neural Information Processing Systems (NIPS), pp. 3675–3683, 2016a.
+
+Tejas D. Kulkarni, Ardavan Saeedi, Simanta Gautam, and Samuel J. Gershman. Deep Successor Reinforcement Learning. CoRR, abs/1606.02396, 2016b.
+
+Marlos C. Machado, Marc G. Bellemare, and Michael Bowling. A Laplacian Framework for Option Discovery in Reinforcement Learning. In Proc. of the International Conference on Machine Learning (ICML), pp. 2295–2304, 2017.
+
+Marlos C. Machado, Marc G. Bellemare, Erik Talvitie, Joel Veness, Matthew Hausknecht, and Michael Bowling. Revisiting the Arcade Learning Environment: Evaluation Protocols and Open Problems for General Agents. Journal of Artificial Intelligence Research (JAIR), In press, 2018.
+
+Sridhar Mahadevan. Proto-value Functions: Developmental Reinforcement Learning. In Proc. of the International Conference on Machine Learning (ICML), pp. 553–560, 2005.
+
+Sridhar Mahadevan and Mauro Maggioni. Proto-value Functions: A Laplacian Framework for Learning Representation and Control in Markov Decision Processes. Journal of Machine Learning Research (JMLR), 8:2169–2231, 2007.
+
+Daniel J. Mankowitz, Timothy Arthur Mann, and Shie Mannor. Adaptive Skills Adaptive Partitions (ASAP). In Advances in Neural Information Processing Systems (NIPS), pp. 1588–1596, 2016.
+
+Amy McGovern and Andrew G. Barto. Automatic Discovery of Subgoals in Reinforcement Learning using Diverse Density. In Proc. of the International Conference on Machine Learning (ICML), pp. 361–368, 2001.
+
+Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Bellemare, Alex Graves, Martin Riedmiller, Andreas K. Fidjeland, Georg Ostrovski, Stig Petersen, Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra, Shane Legg, and Demis Hassabis. Human-level Control through Deep Reinforcement Learning. Nature, 518(7540):529–533, 2015.
+
+Junhyuk Oh, Xiaoxiao Guo, Honglak Lee, Richard L. Lewis, and Satinder P. Singh. ActionConditional Video Prediction using Deep Networks in Atari Games. In Advances in Neural Information Processing Systems (NIPS), pp. 2863–2871, 2015.
+
+Alec Solway, Carlos Diuk, Natalia Cordova, Debbie Yee, Andrew G. Barto, Yael Niv, and ´ Matthew M. Botvinick. Optimal Behavioral Hierarchy. PLOS Computational Biology, 10(8): 1–10, 2014.
+
+Henning Sprekeler. On the Relation of Slow Feature Analysis and Laplacian Eigenmaps. Neural Computation, 23(12):3287–3302, 2011.
+
+Kimberly L. Stachenfeld, Matthew Botvinick, and Samuel J. Gershman. Design Principles of the Hippocampal Cognitive Map. In Advances in Neural Information Processing Systems (NIPS), pp. 2528–2536, 2014.
+
+Kimberly L. Stachenfeld, Matthew M Botvinick, and Samuel J. Gershman. The Hippocampus as a Predictive Map. Nature Neuroscience, 20:1643–1653, 2017.
+
+Richard S. Sutton. Learning to Predict by the Methods of Temporal Differences. Machine Learning, 3:9–44, 1988.
+
+Richard S. Sutton, Doina Precup, and Satinder P. Singh. Between MDPs and Semi-MDPs: A Framework for Temporal Abstraction in Reinforcement Learning. Artificial Intelligence, 112(1-2):181– 211, 1999.
+
+Gerald Tesauro. Temporal Difference Learning and TD-Gammon. Communications of the ACM, 38 (3):58–68, 1995.
+
+Alexander Sasha Vezhnevets, Simon Osindero, Tom Schaul, Nicolas Heess, Max Jaderberg, David Silver, and Koray Kavukcuoglu. FeUdal Networks for Hierarchical Reinforcement Learning. In Proc. of the International Conference on Machine Learning (ICML), pp. 3540–3549, 2017.
+
+T. Wang, M. Bowling, and D. Schuurmans. Dual Representations for Dynamic Programming and Reinforcement Learning. In Proc. of the IEEE International Symposium on Approximate Dynamic Programming and Reinforcement Learning (ADPRL), pp. 44–51, 2007.
+
+Christopher J. C. H. Watkins and Peter Dayan. Technical Note: Q-Learning. Machine Learning, 8 (3-4), May 1992.
+
+Laurenz Wiskott and Terrence J. Sejnowski. Slow Feature Analysis: Unsupervised Learning of Invariances. Neural Computation, 14(4):715–770, 2002.
+
+# APPENDIX: SUPPLEMENTARY MATERIAL
+
+This supplementary material contains details omitted from the main text due to space constraints. The list of contents is below:
+
+• A more detailed proof of the theorem in the paper;   
+• Empirical results evaluating how the number of episodes used to learn the successor representation impacts the obtained eigenvectors and their corresponding eigenoptions;   
+• Evaluation of the reconstruction module (auxiliary task) that learns the latent representation that is used to estimate the successor representation.
+
+# A MORE DETAILED PROOF OF THE THEOREM IN THE MAIN PAPER
+
+Theorem. Stachenfeld et al. (2014): Let $0 < \gamma < 1$ s.t. $\Psi = ( I - \gamma T ) ^ { - 1 }$ denotes the matrix encoding the $S R$ , and let $\mathcal { L } = D ^ { - 1 / 2 } ( D - W ) D ^ { - 1 / 2 }$ denote the matrix corresponding to the normalized Laplacian, both obtained under a uniform random policy. The $i$ -th eigenvalue $( \lambda _ { S R , i } )$ of the $S R$ and the $j$ -th eigenvalue $( \lambda _ { P V F , j } )$ of the normalized Laplacian are related as follows:
+
+$$
+\lambda _ { P V F , j } = \left[ 1 - ( 1 - { \lambda _ { S R , i } } ^ { - 1 } ) \gamma ^ { - 1 } \right]
+$$
+
+The i-th eigenvector $( \mathbf { e } _ { S R , i } )$ of the $S R$ and the $j$ -th eigenvector $( \mathbf { e } _ { P V F , j } )$ of the normalized Laplacian, where $i + j = n + 1$ , with $n$ being the total number of rows (and columns) of matrix $T$ , are related as follows:
+
+$$
+{ \bf e } _ { P V F , j } = ( \gamma ^ { - 1 } D ^ { 1 / 2 } ) { \bf e } _ { S R , i }
+$$
+
+Proof. This proof is more detailed than the one presented in the main paper. Let $\lambda _ { i } , \mathbf { e } _ { i }$ denote the $i$ -th eigenvalue and eigenvector of the SR. Using the fact that the SR is known to converge, in the limit, to $( I - \gamma T ) ^ { - 1 }$ (through the Neumann series), we have:
+
+$$
+\begin{array} { r l } { \frac { ( 1 - \sqrt { 2 } - \sqrt { 3 } ) ! } { 2 } \langle x - y \rangle _ { i } } & { = - \lambda _ { 0 } ! } \\ { ( 1 - \sqrt { 2 } - \sqrt { 3 } ) ! } & { = - \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 2 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 3 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 4 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 5 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 4 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 5 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 6 - \sqrt { 3 } - \Gamma _ { i } ) \Gamma _ { i } } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 7 - \sqrt { 3 } ) ! } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 7 - \sqrt { 3 } ) ! } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 7 - \sqrt { 3 } ) ! } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 5 - \sqrt { 3 } ) ! } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 7 - \sqrt { 3 } ) ! } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\ { ( 4 - \sqrt { 3 } - \Gamma _ { i } ) ! } \\ { ( 5 - \sqrt { 3 } ) ! } & { = \lambda _ { 0 } ! ^ { 2 } \sqrt { 3 } \Gamma _ { i } } \\  ( 6 - \sqrt { 3 } - \Gamma _ { i } ) \end{array}
+$$
+
+THE IMPACT THE NUMBER OF EPISODES HAS IN LEARNING THE SR AND THE EIGENOPTIONS
+
+In Section 4.1 we briefly discussed the impact of estimating the successor representation from samples instead of assuming the agent has access to the normalized Laplacian. It makes much more sense to use the successor representation as the DIF model in the environment if we can estimate it quickly. The diffusion time was the main evidence we used in Section 4.1 to support our claim that early estimates of the successor representation are useful for eigenoption discovery. In order to be concise we did not actually plot the eigenvectors of the estimates of the successor representation at different moments, nor explicitly compared them to proto-value functions or to the eigenvectors of the matrix $( I - \gamma T ) ^ { - 1 }$ . We do so in this section.
+
+Figures 7–10 depict the first four eigenvectors of the successor representation in the Rooms domain, after being learned for different number of episodes (episodes were 100 time steps long, $\eta = 0 . 1$ , $\gamma = 0 . 9$ ). We also depict the corresponding eigenvectors of the $( I - \gamma T ) ^ { - 1 } \ \mathrm { m a t r i x } ^ { 2 }$ , and of the normalized Laplacian (Machado et al., 2017). Because the eigenvectors orientation (sign) is often arbitrary in an eigendecomposition, we matched their orientation to ease visualization.
+
+Overall, after 500 episodes we already have an almost perfect estimate of the first eigenvectors in the environment; while 100 episodes seem to not be enough to accurately learn the DIF model in all rooms. However, learning the successor representation for 100 episodes seems to be enough to generate eigenoptions that reduce the agent’s diffusion time, as we show in Figure 3d. We can better discuss this behavior by looking at Figures 11–14, which depict the options generated by the obtained eigenvectors.
+
+With the exception of the options generated after learning the successor representation for 100 episodes, all the eigenoptions obtained from estimates of the successor representation already move the agent towards the “correct” room(s). Naturally, they do not always hit the corners, but the general structure of the policies can be clearly seen. We also observe that the eigenoptions obtained from proto-value functions are shifted one tile from the corners. As discussed in the main paper, this is a consequence of how Machado et al.’s (2017) dealt with corners. They did not model selfloops in the MDP, despite the fact that the agent can be in the same state for two consecutive steps. The successor representation captures this naturally. Finally, we use Figure 11a to speculate why the options learned after 100 episodes are capable of reducing the agent’s diffusion time. The first eigenoption learned by the agent moves it to the parts of the state space it has never been to, this may be the reason that the combination of these options is so effective. It also suggests that incremental methods for option discovery and exploration are a promising path for future work.
+
+# USING EIGENOPTIONS TO ACCUMULATE REWARD IN THE ENVIRONMENT
+
+In Section 4.1 we also evaluated the agent’s ability to accumulate reward after the eigenoptions have been learned. We further analyze this topic here. As in Section 4.1, the agent learned, off-policy, the greedy policy over primitive actions (target policy) while following the uniform random policy over actions and eigenoptions (behavior policy). We used Q-learning (Watkins $\&$ Dayan, 1992) in our experiments – parameters $\lambda = 0$ , $\alpha = 0 . 1$ , and $\gamma = 0 . 9$ . Episodes were 100 time steps long. Figures 16–19 summarize the obtained results comparing the performance of our approach to regular Q-learning over primitive actions in four different environments ( $\cdot \cdot f .$ Figure 15). We evaluate the agent’s performance when using eigenoptions extracted from estimates of the SR obtained after 100, 500, and 1000 episodes, as well eigenoptions obtained from the true SR, i.e., $( I - \gamma T ) ^ { - 1 }$ . The reported results are the average over 24 independent runs when learning the SR, with each one of these runs encoding 100 runs evaluating Q-Learning. The options were added following the sorting provided by the eigenvalues. For example, 4 options denotes an agent with the action set used in the behavior policy being composed of the four primitive actions and the four eigenoptions generated by the top 2 eigenvalues (both directions are being used).
+
+We can see that eigenoptions are not only capable of reducing the diffusion time in the environment but of also improving the agent’s control performance. They do so by increasing the likelihood that the agent will cover a larger part of the state space given the same amount of time. Interestingly, few eigenoptions seem to be enough for the agent. Moreover, although rough estimates of the SR seem to be enough to improve the agent’s performance (e.g., estimates obtained after only 100 episodes).
+
+More accurate predictions of the SR are able to further improve the agent’s performance, mainly when dozens of eigenoptions are being used. The first eigenoptions to be accurately estimated are those with larger eigenvalues, which are the ones we add first.
+
+# EVALUATION OF THE RECONSTRUCTION TASK
+
+In Section 4.2 we analyzed the eigenoptions we are able to discover in four games of the Arcade Learning Environment. We did not discuss the performance of the proposed network in the auxiliary tasks we defined. We do so here. Figures 20–23 depict a comparison between the target screen that should be predicted and the network’s actual prediction for ten time steps in each game. We can see that it accurately predicts the general structure of the environment and it is able to keep track of most moving sprites on the screen. The prediction is quite noisy, different from Oh et al.’s (2015) result. Still, it is interesting to see how even an underperforming network is able to learn useful representations for our algorithm. It is likely better representations would result in better options.
+
+# EIGENOPTIONS DISCOVERED IN FREEWAY
+
+Figure 6 depicts the two meaningful eigenoptions we were able to discover in the game FREEWAY. As in Figure 5, each option is represented by the normalized count of the avatar’s position on the screen in a trajectory. The trajectories generated by different options are represented by different colors and the color’s intensity at a given location represents how often the agent was at that location.
+
+![](images/da79b9447c3ad6805b13029826a49d939a9648996893413cba62ef657a5002fd.jpg)  
+Figure 6: Eigenoptions discovered in the game FREEWAY.
+
+![](images/3314ad3a182b39024f9937de03c04791bf3b15e9d28148a4ea856ec0567f4dad.jpg)  
+Figure 7: Evolution of the first eigenvector being estimated by the SR and baselines.
+
+![](images/19769b1533c3e9bc3d69696da0031d05c8a6fb2214074201e5715f4f5eab6888.jpg)  
+Figure 8: Evolution of the second eigenvector being estimated by the SR and baselines.
+
+![](images/aedc84e67df25b72079327e404e14bb3514927ed907db587b664f01ba497fc4a.jpg)  
+Figure 9: Evolution of the third eigenvector being estimated by the SR and baselines.
+
+![](images/688b762971f69b007703bf0ef57fb335ee062ff69d18b2af9ddacce13f916768.jpg)  
+Figure 10: Evolution of the fourth eigenvector being estimated by the SR and baselines.
+
+![](images/efcc107598525b5925d469cc09e2c709dd22dfd81c0356e60ebee4e115417a8f.jpg)  
+Figure 11: Evolution of the first eigenoption being estimated by the SR and baselines.
+
+![](images/03a3ab27aeeb3fc281549dd52049a5ad103987584167cc50356b78e53acde1d5.jpg)  
+Figure 12: Evolution of the second eigenoption being estimated by the SR and baselines.
+
+![](images/a49e880a6f407ff4ebed6df6ec90c5e8b2438869359c1023d69b82a595a60123.jpg)  
+Figure 13: Evolution of the third eigenoption being estimated by the SR and baselines.
+
+![](images/af7ae29122af16976903ba435e118dac26735541fac88319cc42bb19c3a0ba3c.jpg)  
+Figure 14: Evolution of the fourth eigenoption being estimated by the SR and baselines.
+
+![](images/1f957e5e6667f074ec47e6d8546dc8485274b9ed303fb4c5c802785528ec646f.jpg)  
+Figure 15: Different environments (varying start and goal locations) used when evaluating the agent’s ability to accumulate reward with and without eigenoptions.
+
+![](images/18b295e9e020669e05d851a6841e86de9a7a61a5d786468aa19de0aeddab9ddf.jpg)  
+Figure 16: Plot depicting the agent’s performance when following options obtained through estimates of the SR (100, 500, and 1, 000 episodes), as well as through the true SR, in environment 1.
+
+![](images/3deca16b97080edebc9c7ceab21aa56c5f706d9f03d6f62b041425dd3a04d815.jpg)  
+Figure 17: Plot depicting the agent’s performance when following options obtained through estimates of the SR (100, 500, and 1, 000 episodes), as well as through the true SR, in environment 2.
+
+![](images/54e6953060c1a8208de97e89cd1266966923d30cc6a69876624a33ed841c45c2.jpg)  
+Figure 18: Plot depicting the agent’s performance when following options obtained through estimates of the SR (100, 500, and 1, 000 episodes), as well as through the true SR, in environment 3.
+
+![](images/12013fa35097e00e851e08c9de50f0caece16c84e3044c2e94c46bc29fb96e4d.jpg)
+
+Figure 19: Plot depicting the agent’s performance when following options obtained through estimates of the SR (100, 500, and 1, 000 episodes), as well as through the true SR, in environment 4.
+
+![](images/a018e40ab047c75f9b9dd7bc5c2e7e6c164c277a7221abfe1a736150073f86b7.jpg)  
+Figure 20: Final 1-step predictions in the game BANK HEIST. We use the task of predicting the next game screen as an auxiliary task when estimating the successor representation.
+
+![](images/251335ccd4c27ae66e19f3f9f53faf0eb708c8a46bd40db4604b6a2724822d03.jpg)  
+Figure 21: Final 1-step predictions in the game FREEWAY. We use the task of predicting the next game screen as an auxiliary task when estimating the successor representation.
+
+![](images/30e6070e53e35b2dabaea2e6c5010b0e517df88b9c176554e7ce2055a920f130.jpg)  
+Figure 22: Final 1-step predictions in the game MONTEZUMA’S REVENGE. We use the task of predicting the next game screen as an auxiliary task when estimating the successor representation.
+
+![](images/74ae97303884f6348b5670b3bfd9b82f657815d825146042888f7c8a87be6509.jpg)  
+Figure 23: Final 1-step predictions in the game MS. PACMAN. We use the task of predicting the next game screen as an auxiliary task when estimating the successor representation.

parse/train/HJYoqzbC-/HJYoqzbC-_content_list.json

@@ -0,0 +1,1264 @@
+[
+    {
+        "type": "text",
+        "text": "A COMPARISON OF SECOND-ORDER METHODS FOR DEEP CONVOLUTIONAL NEURAL NETWORKS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            101,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            171,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            236,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Despite many second-order methods have been proposed to train neural networks, most of the results were done on smaller single layer fully connected networks, so we still cannot conclude whether it’s useful in training deep convolutional networks. In this study, we conduct extensive experiments to answer the question ”whether second-order method is useful for deep learning?”. In our analysis, we find out although currently second-order methods are too slow to be applied in practice, it can reduce training loss in fewer number of iterations compared with SGD. In addition, we have the following interesting findings: (1) When using a large batch size, inexact-Newton methods will converge much faster than SGD. Therefore inexact-Newton method could be a better choice in distributed training of deep networks. (2) Quasi-newton methods are competitive with SGD even when using ReLu activation function (which has no curvature) on residual networks. However, current methods are too sensitive to parameters and not easy to tune for different settings. Therefore, quasi-newton methods with more selfadjusting mechanisms might be more useful than SGD in training deeper networks. ",
+        "bbox": [
+            233,
+            265,
+            764,
+            486
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            510,
+            336,
+            526
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In training deep neural networks and many other machine learning models, first-order methods have been extensively used. Stochastic Gradient Descent (SGD) method has shown positive results on various tasks in practice. It is very easy to implement and suitable to be applied in large-scale machine learning. However, SGD also has certain disadvantages. Practical success usually comes with laborious work of hyper-parameter searching. Furthermore, pure SGD often struggles to regions of loss surface with largely varying magnitudes of curvature (Dauphin et al., 2014). More importantly, it is very difficult to parallelize SGD—when increasing batch size, it is known that SGD will converge slowly and often obtain a solution with relatively poor generalization error (Keskar et al., 2016; Kawaguchi et al., 2017). ",
+        "bbox": [
+            174,
+            541,
+            825,
+            666
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Second-order methods, on the other hand, improves the search direction using exact or approximate Hessian. Using curvature information enables such methods to make more progress per step than first-order methods relying solely on the gradient. Unfortunately, it is relatively hard to implement an efficient second-order method for large-scale deep neural networks. As parameters in the model scale up to millions, storing full hessian matrix is simply infeasible. Besides, larger datasets makes calculating exact or approximate hessian over whole dataset impossible. We will need to adopt the same mini-batch scheme as in SGD—using sub-sampled hessian in a data batch to calculate the update direction. Stochastic hessian cannot guarantee the approximated local quadratic problem to be positive semidefinite. Consequently the calculated update direction might not be a descent direction and the guarantee of the faster convergence rate of second-order method might not hold. ",
+        "bbox": [
+            174,
+            672,
+            825,
+            811
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "To overcome these challenges, few second-order methods have been proposed in the literature. Most of these methods can be categorized into into stochastic inexact-Newton methods and stochastic quasi-Newton methods, and both types of methods show certain advantages in their experimental results. However, when we try to answer the question ”whether second-order method is useful for deep learning”, we are still unsure the answer. The reasons are as follows. ",
+        "bbox": [
+            174,
+            819,
+            823,
+            888
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "First, the reported results in previous methods usually are based on reduce of training loss versus number of epochs. But to compute an update direction, these methods incur the extra costs of having to compute second-order information, so overall training time might become too long to really use those methods in practice. We need a comparison of training loss versus training time to evaluate the applicability of second-order methods. ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            176,
+            103,
+            823,
+            145
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "More importantly, previous methods are mostly tested on simple networks such as multi-layer fully connected networks rather than deep convolutional network, which is deemed as the standard model in applying neural networks these days. Indeed, a similar study has been conducted before (Ngiam et al., 2011), but models used in the study are mostly shallow autoencoders and only one secondorder method is compared. It is still not obvious to us the advantage of second-order methods and to what extent these methods are useful in training modern deep networks, especially convolutional neural networks. ",
+        "bbox": [
+            174,
+            152,
+            825,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Hence, instead of proposing yet another second-order method, in this study we step back to experiment with some representative second-order methods on two datasets with various settings, and analyze both success and failure cases of second-order methods to conclude the advantages and limits of it. And we hope these information can be used in the future when designing new second-order methods. ",
+        "bbox": [
+            174,
+            257,
+            825,
+            327
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Through this study, our major findings are as follows. ",
+        "bbox": [
+            176,
+            333,
+            524,
+            348
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• Second-order methods can achieve better training loss in fewer number of epochs. This confirms that curvature information is still useful when training convolutional networks.   \n• Larger batch size benefits inexact-Newton methods more than SGD but not the case for quasi-Newton methods.   \n• Currently, second-order methods are too slow to be considered practical in training deep neural networks as compared to SGD.   \n• Network structures with zero second-order derivatives will deteriorate performance of inexact-Newton methods but not quasi-Newton methods.   \n• Fixed learning rate is not applicable to second-order methods ",
+        "bbox": [
+            215,
+            363,
+            825,
+            518
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "We will review the existing second-order works in the next section, and experimental and analysis will be given subsequently to support our claims above. ",
+        "bbox": [
+            174,
+            532,
+            823,
+            560
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 EXISTING SECOND-ORDER METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            583,
+            519,
+            599
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Essentially, second-order methods obtain the update direction by minimizing a quadratic approximate function around the current solution, and the update rule can often be written as ",
+        "bbox": [
+            173,
+            616,
+            821,
+            645
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7b87ea3362d348cd5b97e09d67d15673d0c2d8a2a25905d626bbc6959f1f6bfa.jpg",
+        "text": "$$\nw _ { k + 1 } = w _ { k } - \\alpha _ { k } H _ { k } { \\hat { \\nabla } } f ( w _ { k } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            398,
+            654,
+            599,
+            672
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "where $H _ { k }$ is the inverse of Hessian or its approximation. For large-scale deep network training, due to the huge amount of parameters, all second-order methods need to approximate the calculation of (1) in certain ways. Based on the approximations they made, second-order methods can be categorized into following types. ",
+        "bbox": [
+            174,
+            681,
+            825,
+            738
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 STOCHASTIC INEXACT-NEWTON METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            757,
+            516,
+            772
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The first family of algorithms, called ”inexact-Newton method”, use exact Hessian inverse as $H _ { k }$ but compute $H _ { k } \\nabla f ( w _ { k } )$ inexactly. In (Martens & Sutskever, 2011), a ”Hessian-free” approach is proposed. By using hessian-vector products, Newton updates can be solved by Conjugate Gradient (CG) inexactly, in which the search direction is computed by applying CG to the Newton method, and terminating it once it has made sufficient progress. Hessian-vector products can be computed efficiently using a form of automatic differentiation supported by most popular deep learning frameworks. (Wang et al., 2015) proposed a similar method which solves Newton equation with gradient replaced by linear combination of current and previous gradients. In practice, this method does not show prominent improvement over basic inexact-Newton method; therefore, we choose method in (Martens & Sutskever, 2011) to represent this category. ",
+        "bbox": [
+            173,
+            784,
+            825,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.2 STOCHASTIC QUASI-NEWTON METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            498,
+            117
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Recently, several stochastic quasi-Newton algorithms have been developed for large-scale machine learning (Wang et al., 2017; Curtis, 2016; Keskar & Berahas, 2016; Ramamurthy & Duffy, 2016; Byrd et al., 2016). These methods use approximate hessian instead of the real one for (1), and they differ from each other by using different criteria to obtain curvature pairs and different frequencies of updating. Basically, the spirit of Quasi-Newton methods is to obtain a lower per-iteration cost but good enough second-order approximation to have better update per iteration. (Wang et al., 2017) and (Curtis, 2016) modify the BFGS update rule to prevent the updates steps from becoming unbounded values. (Byrd et al., 2016) extends L-BFGS method by decoupling of the parameter updates from the curvature estimation to achieve a better stability when dealing with large-scale problems. (Keskar & Berahas, 2016) further extended this direction by adding more checking conditions to make sure the update direction is likely descendent. In addition, they approximate empirical fisher information matrix instead of hessian matrix. (Ramamurthy & Duffy, 2016) proposed to use rank one approximation in a limited memory version manner. It combines L-SR1 method with either Line Search or Trust Region scheme to optimize the model. Notice that not all methods above are proposed specifically for non-convex problems. But even as proposed in (Keskar & Berahas, 2016) which claims its applicability for non-convex problem, in our implementation we found out the empirical fisher information becomes too small and the corresponding update is negligible. Both (Wang et al., 2017) and (Curtis, 2016) don’t provide large-scale derivation in their methods and to directly implement their method, large size of hessian information needed to be stored, which is in feasible in our experiments. Therefore, we only choose (Byrd et al., 2016) and (Ramamurthy & Duffy, 2016) to represent this category. ",
+        "bbox": [
+            174,
+            130,
+            825,
+            421
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.3 STOCHASTIC GAUSS-NEWTON METHODS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            439,
+            501,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Gauss-Newton is a positive semidefinite approximation to the hessian matrix. In (Botev et al., 2017), an efficient block-diagonal approximation to the Gauss-Newton matrix for multi-layer fully connected networks is proposed. It represents the approximation by Kronecker Product and factorize it to achieve an easier calculation. A similar work was done in (Martens & Grosse, 2015). The difference is that in (Martens & Grosse, 2015), Fisher-information matrix instead of hessian matrix is approximated. Although we want to include this type of optimization methods in comparison, these methods requires dedicate implementation for each type of neural network. When the network contains layers that are not fully connected and possibly with weight sharing, such as convolutional layers, it is hard to exploit the Kronecker product structure to form the Gauss-Newton matrix. Since we are focusing on convolutional neural networks in this paper, we did not take this category into comparison. ",
+        "bbox": [
+            174,
+            465,
+            825,
+            617
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.4 TRUST-REGION METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            636,
+            397,
+            650
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Trust region methods are another important family of second-order methods. Instead of solving the linear system in (1), they obtain the update direction by minimizing the quadratic approximation around the current solution with the norm constraints. The 2-norm constraint, known as “trust region”, is used to prevent the iterate from moving too far. However, this non-convex quadratic subproblem with bounded constraint is non-trivial to solve for large-scale applications, thus trust region methods have not been studied much for training deep networks. Similar to trust region method, cubic regularization method (Nesterov & Polyak, 2006) solves a similar subproblem but replaces the bounded constraints by cubic regularization. Just before submitting this work, a recent paper (Xu et al., 2017b;a) on arXiv tested a trust region method and cubic regularization method on multi-layer perceptons, but it has not been applied to convolutional neural network. We will try to include this type of methods into comparison in the future. ",
+        "bbox": [
+            174,
+            662,
+            825,
+            815
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTAL SETUPS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            837,
+            406,
+            853
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "3.1 DATASETS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            868,
+            287,
+            883
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "We will use MNIST and CIFAR-10 datasets in the experiments. MNIST consists of 60,000 1x28x28 images of hand-written digits. In this study, we report results based on all 60,000 images including both training and validation sets. CIFAR-10 dataset consists of $6 0 , 0 0 0 \\ 3 \\mathrm { x } 3 2 \\mathrm { x } 3 2$ colour images in 10 classes, with 6,000 images per class. We follow the same setting as provided with 50,000 training images and 10,000 test images. There are many data augmentation methods mentioned in the literature; however, as our analysis focuses more on optimization rather than achieving highest accuracy, we didn’t augment datasets. ",
+        "bbox": [
+            174,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/a92067555ce37678016ada020b7fadbf99b3481907052a1003ad556c4960770f.jpg",
+        "table_caption": [
+            "Table 1: Testing accuracy achieved by SGD for eahc model. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td></td><td>MNIST</td><td>CIFAR-10</td></tr><tr><td>LeNet</td><td>99.2</td><td>69</td></tr><tr><td>AlexNet</td><td>99.4</td><td>77.48</td></tr><tr><td>DRN</td><td>99.3</td><td>82.3</td></tr></table>",
+        "bbox": [
+            380,
+            127,
+            617,
+            186
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            218,
+            825,
+            289
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.2 MODELS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            276,
+            320
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In this study, we are interested in analyzing performance of second-order methods on convolutional neural networks. We first start with the basic LeNet5 (LeCun et al., 1995), and then test results with AlexNet (Krizhevsky et al., 2012), which can be thought as adding more layer of convolutions with larger number of filters. Last, we evaluate optimization methods on latest 18-layer Deep Residual Network(DRN) (He et al., 2016). For LeNet, we have 2 convolutional layers with 20 and $5 0 ~ 5 \\mathrm { x } 5$ filters. For AlexNet, 3 convolutional layers with 64, 64, 128 5x5 filters are used. For DRN, we follow the same implementation as listed in (He et al., 2016). Best testing accuracy achieved by fixed learning rate SGD for each model is listed in Table 1. ",
+        "bbox": [
+            174,
+            333,
+            823,
+            444
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Notice that there are certain different settings we used as compared to standard deep neural networks. First, the nonlinear activation unit used in all our implementations except few designed experiments is tanh instead of ReLu. As we will show in the following discussions, ReLu will cause the vanishing second-order information and thus prohibit the training with stochastic inexact-Newton methods. Second, we used fixed learning rate of SGD instead of having a decaying schedule. As this study mainly wants to investigate the effectiveness of second-order information over first-order gradients, we stick to the most basic usage of first-order method. ",
+        "bbox": [
+            174,
+            452,
+            825,
+            549
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Finally, we restrict ourselves to SGD without momentum since our goal is to study whether secondorder information is useful. Because of these reasons and no data augmentation, our reported best test accuracy might not be the same as in the literature. We verified that with decaying schedule, data augmentation and momentum used, our DRN implementation on CIFAR-10 can achieve around $9 3 \\%$ test accuracy and this is almost the same as in (He et al., 2016). ",
+        "bbox": [
+            174,
+            556,
+            825,
+            626
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.3 OPTIMIZATION METHODS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            643,
+            392,
+            657
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "We will compare SGD with one inexact-Newton method and two quasi-Newton methods. For inexact-Newton method, we compare with the hessian-free method proposed in (Martens & Sutskever, 2011), which uses Stochastic Hessian and full Gradient (SHG), and compute the update direction by conjugate gradient method. Computation of full gradient is time-consuming and sometimes is not necessary when applying this method. On MNIST with LeNet model, we show in Figure 1 that SHG with larger full gradient used is indeed better, but it’s not significantly better than only partial gradients. Therefore, in our experiment when applying SHG we will only use $2 0 \\%$ of data to compute the gradient. For quasi-Newton method, we use L-SR1 (SR1) (Ramamurthy & Duffy, 2016) and Stochastic Quasi-Newton method (SQN) (Bollapragada et al., 2016) as representative. In this study, results are based on selecting batch size as 100 except for certain designed experiments. As we are trying to understand the best applicability of each method, all the hyper-parameters are tuned to achieve the best possible results. ",
+        "bbox": [
+            174,
+            670,
+            825,
+            837
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "3.4 FIX LEARNING RATE VERSUS LINE SEARCH",
+        "text_level": 1,
+        "bbox": [
+            174,
+            854,
+            522,
+            869
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "While in (Byrd et al., 2016) a decaying schedule $1 / k$ ,where $\\mathbf { k }$ is the current number of iteration, is proposed to be the step size of each update, in practice we find out this scheme does not work on most of our experiments. Instead, we improve the stability by applying line search to find out the ",
+        "bbox": [
+            176,
+            882,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "image",
+        "img_path": "images/b59153e177dc1e92dcd9b117b4555c7a9632a2f00d40b3ed70354a30cb3db724.jpg",
+        "image_caption": [
+            "Figure 1: Percentage of data (or simply one batch) used to calculate gradient used in SHG method. We can see $2 0 \\%$ data to compute gradient is enough. One epoch refers to iterate whole dataset once. Following figures follow the same definition. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            338,
+            106,
+            656,
+            255
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "step size. We adopt the backtracking line search and accept the step size whenever it satisfies the following sufficient decrease condition (see (Wright, 2008)): ",
+        "bbox": [
+            173,
+            343,
+            823,
+            371
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "equation",
+        "img_path": "images/1c962632b98d274c80e89187e41db360afd152f76d11e7c69121b637a80bc935.jpg",
+        "text": "$$\n\\begin{array} { r } { f ( w + \\eta p ) - f ( w ) \\leq 0 . 1 \\eta \\nabla f ( w ) ^ { T } p , } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            377,
+            624,
+            396
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "where $p$ is the search direction, and both gradient and function values are computed using the current batch. In this study, without further notice, SGD and GD will use well tuned fix learning rate and we will apply line search for SHG, SQN and SR1. Due to this finding, we are also interested in knowing whether line search is essential when applying second-order methods. Analysis will be provided below. ",
+        "bbox": [
+            174,
+            400,
+            825,
+            470
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4 RESULTS AND ANALYSIS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            413,
+            507
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "4.1 SHG OUTPERFORMS SGD IN NUMBER OF TRAINING STEPS BUT SGD IS SUBSTANTIALLY FASTER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            522,
+            710,
+            550
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We show MNIST results in Figure 2 and CIFAR-10 results in Figure 3. Is second-order methods useful in training deep neural network? By only looking at number of epochs to minimize training objective, we can clearly answer yes. SHG method performs well on both datasets, and quasi-Newton methods have slightly worse performance on MNIST but are significantly better than SGD on CIFAR-10. Another point to notice is that we could not find a set of parameters to make SQN work with AlexNet on CIFAR-10. This signals that quasi-Netwon methods without parameter control or self-adjusting features can easily fall short in training non-convex problems. ",
+        "bbox": [
+            174,
+            561,
+            825,
+            660
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It might be argued that as each update, SHG accesses much more data $2 0 \\%$ of total as mentioned) than SGD (one batch), so it is self-evident that SHG can have better results. Nevertheless, we also include the Gradient Descent (GD) method to verify that amount of data accessed is not the key to performance in this case. In each iteration, GD will use average gradient of $2 0 \\%$ of data to be the update direction. So GD has same number of updates as SGD, and access same amount of data as SHG in each update. If amount of data accessed were the key, GD should have a similar performance as SHG method. But we can clearly tell from the both figures that GD has a very different training loss curve from SHG. GD is actually worse than SGD in most cases which indicates that aggregated gradient information is not helpful in training deep neural networks. This verifies the effectiveness of second-order information. ",
+        "bbox": [
+            174,
+            666,
+            825,
+            805
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Thus, second-order methods sound like a promising optimization method in deep learning. But when we look at the time spent to optimize as shown in Figure 4 and 5, clearly second-order methods won’t be a practical choice. SHG takes hundred to thousand times more to finish the training. This is because SHG needs to computes (almost) full gradient information. As the training data grows larger, this will be a demanding computational task. We also include time required to achieve a designated accuracy for both datasets. SGD is still substantially faster than all second-order methods. Quasi-Newton methods in general take shorter time to train and achieve decent testing results. Especially SQN is the fastest among three second-order methods. It is because SQN decouples the computation of update pairs and parameter updates. Therefore, in each iteration the required computation is reduced. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/7d506e26a930b7527165cf6abceebf01fdf9417aa89a6a04371e953423bf8ad0.jpg",
+        "image_caption": [
+            "Figure 2: Average training loss versus epochs of SGD, SHG, GD, SR1, SQN on MNIST dataset. SHG is slightly faster than SGD. Quasi-Newton methods are comparable to SGD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            103,
+            810,
+            448
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            522,
+            823,
+            551
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In our implementation, computation of full gradient is done by iterating many smaller batches. Ideally, we could parallelize this operation to accelerate the SHG method so SHG might become competitive to SGD in time when distributed training is available. Furthermore, in next section we will show SHG benefits from big batches, which is also a good feature for parallelizing the computation. ",
+        "bbox": [
+            176,
+            558,
+            823,
+            628
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/396cfe981f736da26f857d64ed6604f62c3cc60c7704e201def2f3392f199af0.jpg",
+        "table_caption": [],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1></td><td rowspan=1 colspan=1>MNIST</td><td rowspan=1 colspan=1>CIFAR-10</td></tr><tr><td rowspan=1 colspan=1>LeNet   AlexNet</td><td rowspan=1 colspan=1>LeNet   AlexNet</td></tr><tr><td rowspan=1 colspan=1>SGD</td><td rowspan=1 colspan=1>4.4      4.0</td><td rowspan=1 colspan=1>89.7     51.3</td></tr><tr><td rowspan=1 colspan=1>SHG</td><td rowspan=1 colspan=1>183      122</td><td rowspan=1 colspan=1>1422    1856</td></tr><tr><td rowspan=1 colspan=1>SQN</td><td rowspan=1 colspan=1>71.9     50.7</td><td rowspan=1 colspan=1>229      NA</td></tr><tr><td rowspan=1 colspan=1>SR1</td><td rowspan=1 colspan=1>172.9    121.9</td><td rowspan=1 colspan=1>2744    483</td></tr></table>",
+        "bbox": [
+            339,
+            641,
+            656,
+            729
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Table 2: Time(sec) required to achieve desginated testing accuracy, MNIST: $9 8 \\%$ and CIFAR$1 0 { : } 7 3 \\%$ ",
+        "bbox": [
+            171,
+            739,
+            823,
+            767
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "4.2 SHG PERFORMS BETTER UNDER BIG BATCH SETTING ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            792,
+            583,
+            808
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "It has been observed that increasing the batch size will hurt the convergence speed of SGD (Goyal et al., 2017; ?; You et al., 2017). Therefore, it is interesting to see the performance of second-order methods as we increase batch size. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            861
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In Figure 6, we test the performance of SQN when we increase batch size. As we can see, SQN works well when batch size is small but the training becomes stagnant when batch size becomes larger. We believe it’s because there are many hyper-parameters in quasi-Newton methods such as batch size, number of curvature pairs to use, learning rate and frequency of updates. Again without a good controlling mechanism, the approximation computed might be noisy and sudden change one of any parameters alone will make the algorithm problematic. Same situation can be observed in SR1 as shown in Figure 7. Its performance becomes worse than SGD when the batch size is increased. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/117b56239de3b838f5a2111aad818b00fbcd5ed9375305f67f650f29b9b28567.jpg",
+        "image_caption": [
+            "Figure 3: Average training loss versus epochs of SGD, SHG, GD, SR1, SQN on CIFAR-10 dataset. Clearly both inexact-Newton and quasi-Newton methods optimize the training loss faster than SGD. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            102,
+            807,
+            444
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            523,
+            825,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the other hand, the behavior is totally different for inexact-Newton method such as SHG—SHG benefits from bigger batches, as shown in Figure 8. Although the effect of larger batches seems to be stronger for SGD when batch size grows to 400, SHG with even larger sizes (e.g., 3200) will outperform SGD more when compared to smaller batch sizes. This implies unlike first-order methods which rely on the noisy of gradient estimation to jump out the valley, curvature information captured by SHG is enough to optimize the objective function, and larger batch size of hessian-vector product used in SHG leads to better results. When batch size is larger, it’s even easier to parallelize and compute the full gradient part. This shows a good direction to apply second-order methods in the future. ",
+        "bbox": [
+            173,
+            571,
+            825,
+            696
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.3 LIMITS OF SECOND-ORDER METHODS: RELU UNIT AND IDENTITY LINK ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            718,
+            720,
+            734
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "At first glance, second-order methods especially SHG can achieve good results with standard deep convolutional neural networks. But when it comes to Deep Residual Network, the story is different as shown in Figure 9. SHG is able to train a DRN on MNIST but not CIFAR-10. As derived in (Botev et al., 2017), hessian matrix of multi-layer fully connected network will be related to this recursive pre-activation hessian $_ \\mathrm { H }$ : ",
+        "bbox": [
+            174,
+            747,
+            825,
+            818
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f137eb08a80021079e3ee316343f8a7e6287a81c769867720b40509e8cf53f7b.jpg",
+        "text": "$$\nH _ { \\lambda } = B _ { \\lambda } W _ { \\lambda + 1 } ^ { T } H _ { \\lambda + 1 } W _ { \\lambda + 1 } B _ { \\lambda } + D _ { \\lambda }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            372,
+            829,
+            624,
+            849
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where we could define the diagonal matrices: ",
+        "bbox": [
+            176,
+            867,
+            472,
+            881
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/5dbf35f322592fbb8086a9632bccb788acfe25f43350a0609201309ecfe1ec1e.jpg",
+        "text": "$$\nB _ { \\lambda } = \\mathrm { d i a g } ( f _ { \\lambda } ^ { \\prime } ( h _ { \\lambda } ) )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            431,
+            907,
+            566,
+            925
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/eb9810a45d4749ae95baaaea5fd1b3f94b3231311e964401a335c607b61f74e1.jpg",
+        "image_caption": [
+            "Figure 4: Average training loss versus time of SGD,SHG,GD,SR1,SQN on MNIST dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            101,
+            812,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "equation",
+        "img_path": "images/523bd1fd5034451f574271cebe9cc95c4457600fcaedd28ee07f995daa61d9bd.jpg",
+        "text": "$$\nD _ { \\lambda } = \\mathrm { d i a g } ( f _ { \\lambda } ^ { \\prime \\prime } ( h _ { \\lambda } ) { \\frac { \\partial E } { \\partial a _ { \\lambda } } } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            415,
+            554,
+            583,
+            587
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "where E is the total loss, f is the activation function and $a _ { \\lambda }$ is the activation of certain layer $\\lambda$ . Therefore, if ReLu is used as nonlinear unit of the network, it will have zero second-order derivatives so part of the hessian information will be lost. In addition, identity link used in the DRN also has zero second-order derivatives. Since DRN contains both designs, we are not sure which unit deteriorates SHG more. Therefore, we design an ablation test to verify the effects. ",
+        "bbox": [
+            174,
+            617,
+            823,
+            688
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "First, we compare AlexNet with tanh and AlexNet with ReLu. This is a straightforward comparison to understand the influence of using ReLu. Next, we take AlexNet with tanh and substitute the last convolutional layer in AlexNet with a single residual block. Within the block, again tanh is used instead of ReLu and we keep the identity link. Although it’s a relatively shallow network compared to the one used in DRN, it’s enough to tell the influence of using identity link. As shown in Figure 10 and 11, both designs will deteriorate the performance of SHG. And ReLu posts stronger challenges to this type of second-order methods. This is a really problematic issue as nowadays, popularity of DRN grows fast and likely it will become the standard type of neural network. Without an efficient way of solving this problem means SHG won’t be useful even it can be parallelized. On contrary, quasi-Newton methods use first-order information to approximate second-order information. Despite the second-order information is disrupted by vanishing effect, it can still receive gradients to complete the calculation. Besides, we observe that it converges to smaller training loss than SGD on both MNIST and CIFAR-10. It has the potential to be applied in training deeper residual networks. ",
+        "bbox": [
+            174,
+            694,
+            825,
+            875
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "The reason why SHG still works on training MNIST is likely due to the fact that images in MNIST are simple patterns with most parts black. So the information lost is not severe enough to stop us from training. But in general it should become an issue on most of real-world datasets. ",
+        "bbox": [
+            176,
+            881,
+            823,
+            924
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/0d3556ad7c642e95de87bf6052fc72cded8492d2b05dd6a8a4cb119f45bab3b3.jpg",
+        "image_caption": [
+            "Figure 5: Average training loss versus time of SGD,SHG,GD,SR1,SQN on CIFAR-10 dataset. SGD in practice requires minimal computations and consequently faster than second-order methods. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            179,
+            102,
+            812,
+            446
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/9c3282b1f4dd944c86b7ee53d56cb51770c23488c71a6b24676c292c3a8152a7.jpg",
+        "image_caption": [
+            "Figure 6: Effect of changing batch size of SQN method. SQN fails to generalize the performance to larger batches. In principle SQN is sentitive to hyper-parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            343,
+            540,
+            648,
+            710
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "4.4 LINE SEARCH IS ESSENTIAL TO SECOND-ORDER METHODS",
+        "bbox": [
+            174,
+            815,
+            629,
+            829
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this part, we replace the line search computations with well tuned fixed learning rate. In sum, second-order methods will not work on most of cases as shown in figure 12. As each update might not be descent direction, larger step sizes usually cause model to explode at certain point of training. With a fixed step size, only smaller values could be chosen. Consequently, the training process is relatively stagnant. The full capability of second-order methods cannot be achieved. ",
+        "bbox": [
+            174,
+            853,
+            825,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/74ae4feb605195a28019dc66325dda32d6ab1ea5934a00b68a403b8db7de6fa9.jpg",
+        "image_caption": [
+            "Figure 7: Effect of changing batch size of SGD and SR1 methods. SR1 is sensitive to batch size too. As batch size grows, SGD outperforms SR1 on both datasets. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            101,
+            816,
+            452
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSIONS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            525,
+            328,
+            541
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Second-order information is helpful to reduce the number of training epochs needed but it severely suffers from computational cost. So presently, light-weight first-order methods still dominate the optimization of deep neural network. Fortunately, both inexact-Newton methods and quasi-Newton methods seem to have certain ways to improve in the future. For inexact-Newton methods, parallelization is obviously the most promising direction to further study. With bigger batches and proper distributed system supported, it has a chance to achieve competitive results in practical timing constraints. Nevertheless, we will need to figure out how to deal with vanishing second-order information to make it really useful in deep learning. ",
+        "bbox": [
+            174,
+            556,
+            825,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "For quasi-Newton method, although currently it is fast enough to be considered as the same order as SGD, a good balance between the precision of approximation and frequency of updates should still be considered to further cut the computational time. In addition, a more efficient and safer selfadjusting or correction mechanism can be added to make it stable under different setup of parameters and batch sizes. In addition, from preliminary analysis, quasi-Newton methods show competitive results when training DRN on both MNIST and CIFAR-10. This is another interesting research direction to explore. ",
+        "bbox": [
+            173,
+            675,
+            825,
+            772
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "image",
+        "img_path": "images/4a918bceba5e9385e39b1f7c96b0f2a700d0ac7950318a60be570be7fd2d1e52.jpg",
+        "image_caption": [
+            "Figure 8: Effect of changing batch size of SGD and SHG methods. SGD benefits a bit when batch size grows to 400 but not larger. SHG outperforms SGD significantly when batch size keeps growing. Notice that large batch size means smaller number of updates in each epoch. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            146,
+            818,
+            496
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/01f1b93fae803d8b3498c2594f848a5aed9db7f4bb78ef4f9e7b1e4fd1ce8251.jpg",
+        "image_caption": [
+            "Figure 9: Results of training regular DRN with ReLu activation. Although SHG can still optimize DRN on MNIST well, it fails to converge to better training loss on CIFAR-10 dataset. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            655,
+            815,
+            829
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "image",
+        "img_path": "images/559aacb55b499ae8f3adffc23415cfe7b7fa142d5858ef6c4e4de60fffd5673b.jpg",
+        "image_caption": [
+            "Figure 10: Effect of using ReLu in AlextNet. Left figure is Regular AlexNet with tanh activation and right figure is AlexNet with ReLu activation. Apparently using ReLu in deep neural networks deteriorates performance of SHG but not SR1. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            121,
+            816,
+            292
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/d00c6857b425ff567092c45773ca41afcb1c801186eaec4f86561ba9261fb259.jpg",
+        "image_caption": [
+            "Figure 11: Effect of adding Identity expression in AlexNet. Left figure is Regular AlexNet with tanh activation and right figure is AlexNet with last convolutional layer replaced by a residual block. The influence of identity link is not as strong as ReLu but still affects the performance of SHG. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            400,
+            818,
+            574
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "image",
+        "img_path": "images/79dcb4b7b16dfaafa0731fe712a223c1698a3c8d4f8aeb4888bb26c17b66b192.jpg",
+        "image_caption": [
+            "Figure 12: Effect of using fixed learning rate of SGD and SR1 methods. Second-order methods cannot work with fixed learning rate. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            176,
+            679,
+            816,
+            854
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            287,
+            117
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Raghu Bollapragada, Richard Byrd, and Jorge Nocedal. Exact and inexact subsampled newton methods for optimization. arXiv preprint arXiv:1609.08502, 2016. ",
+        "bbox": [
+            174,
+            126,
+            823,
+            155
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Aleksandar Botev, Hippolyt Ritter, and David Barber. Practical gauss-newton optimisation for deep learning. In ICML, 2017. ",
+        "bbox": [
+            173,
+            162,
+            821,
+            191
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Richard H Byrd, Samantha L Hansen, Jorge Nocedal, and Yoram Singer. A stochastic quasi-newton method for large-scale optimization. SIAM Journal on Optimization, 26(2):1008–1031, 2016. ",
+        "bbox": [
+            173,
+            199,
+            821,
+            229
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Frank Curtis. A self-correcting variable-metric algorithm for stochastic optimization. In International Conference on Machine Learning, pp. 632–641, 2016. ",
+        "bbox": [
+            173,
+            237,
+            823,
+            266
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yann N Dauphin, Razvan Pascanu, Caglar Gulcehre, Kyunghyun Cho, Surya Ganguli, and Yoshua Bengio. Identifying and attacking the saddle point problem in high-dimensional non-convex optimization. In Advances in neural information processing systems, pp. 2933–2941, 2014. ",
+        "bbox": [
+            176,
+            273,
+            823,
+            318
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Priya Goyal, Piotr Dollar, Ross Girshick, Pieter Noordhuis, Lukasz Wesolowski, Aapo Kyrola, An-´ drew Tulloch, Yangqing Jia, and Kaiming He. Accurate, large minibatch sgd: Training imagenet in 1 hour. arXiv preprint arXiv:1706.02677, 2017. ",
+        "bbox": [
+            176,
+            324,
+            821,
+            367
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016. ",
+        "bbox": [
+            173,
+            376,
+            821,
+            419
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Kenji Kawaguchi, Leslie Pack Kaelbling, and Yoshua Bengio. Generalization in deep learning. arXiv preprint arXiv:1710.05468, 2017. ",
+        "bbox": [
+            169,
+            426,
+            823,
+            455
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar and Albert S Berahas. adaqn: An adaptive quasi-newton algorithm for training rnns. In Joint European Conference on Machine Learning and Knowledge Discovery in Databases, pp. 1–16. Springer, 2016. ",
+        "bbox": [
+            174,
+            464,
+            823,
+            507
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Nitish Shirish Keskar, Dheevatsa Mudigere, Jorge Nocedal, Mikhail Smelyanskiy, and Ping Tak Peter Tang. On large-batch training for deep learning: Generalization gap and sharp minima. arXiv preprint arXiv:1609.04836, 2016. ",
+        "bbox": [
+            174,
+            515,
+            823,
+            558
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep convolutional neural networks. In Advances in neural information processing systems, pp. 1097–1105, 2012. ",
+        "bbox": [
+            174,
+            565,
+            825,
+            608
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yann LeCun, LD Jackel, Leon Bottou, Corinna Cortes, John S Denker, Harris Drucker, Isabelle ´ Guyon, UA Muller, Eduard Sackinger, Patrice Simard, et al. Learning algorithms for classification: A comparison on handwritten digit recognition. Neural networks: the statistical mechanics perspective, 261:276, 1995. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            672
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Roger Grosse. Optimizing neural networks with kronecker-factored approximate curvature. In ICML, 2015. ",
+        "bbox": [
+            171,
+            681,
+            821,
+            710
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "James Martens and Ilya Sutskever. Learning recurrent neural networks with hessian-free optimization. In Proceedings of the 28th International Conference on Machine Learning (ICML-11), pp. 1033–1040, 2011. ",
+        "bbox": [
+            173,
+            718,
+            823,
+            761
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Yurii Nesterov and Boris T Polyak. Cubic regularization of newton method and its global performance. Mathematical Programming, 108(1):177–205, 2006. ",
+        "bbox": [
+            176,
+            768,
+            820,
+            799
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Jiquan Ngiam, Adam Coates, Ahbik Lahiri, Bobby Prochnow, Quoc V Le, and Andrew Y Ng. On optimization methods for deep learning. In Proceedings of the 28th international conference on machine learning (ICML-11), pp. 265–272, 2011. ",
+        "bbox": [
+            174,
+            806,
+            823,
+            851
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Vivek Ramamurthy and Nigel Duffy. L-sr1: A second order optimization method for deep learning. https://openreview.net/pdf?id=By1snw5gl, 2016. ",
+        "bbox": [
+            176,
+            858,
+            820,
+            887
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Chien-Chih Wang, Chun-Heng Huang, and Chih-Jen Lin. Subsampled hessian newton methods for supervised learning. Neural computation, 2015. ",
+        "bbox": [
+            176,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 12
+    },
+    {
+        "type": "text",
+        "text": "Xiao Wang, Shiqian Ma, Donald Goldfarb, and Wei Liu. Stochastic quasi-newton methods for nonconvex stochastic optimization. SIAM Journal on Optimization, 27(2):927–956, 2017. ",
+        "bbox": [
+            174,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Jorge Nocedal Stephen J Wright. Numerical optimization. 2008. ",
+        "bbox": [
+            173,
+            140,
+            599,
+            156
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Peng Xu, Farbod Roosta-Khorasan, and Michael W Mahoney. Second-order optimization for nonconvex machine learning: An empirical study. arXiv preprint arXiv:1708.07827, 2017a. ",
+        "bbox": [
+            176,
+            165,
+            821,
+            194
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Peng Xu, Farbod Roosta-Khorasani, and Michael W Mahoney. Newton-type methods for nonconvex optimization under inexact hessian information. arXiv preprint arXiv:1708.07164, 2017b. ",
+        "bbox": [
+            173,
+            203,
+            821,
+            232
+        ],
+        "page_idx": 13
+    },
+    {
+        "type": "text",
+        "text": "Yang You, Zhao Zhang, Cho-Jui Hsieh, and James Demmel. 100-epoch imagenet training with alexnet in 24 minutes. arXiv preprint arXiv:1709.05011, 2017. ",
+        "bbox": [
+            173,
+            241,
+            823,
+            270
+        ],
+        "page_idx": 13
+    }
+]

parse/train/HJeq43AqF7/HJeq43AqF7.md

@@ -0,0 +1,261 @@
+# UNSUPERVISED LATENT TREE INDUCTION WITH DEEP INSIDE-OUTSIDE RECURSIVE AUTO-ENCODERS
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Syntax is a powerful abstraction for language understanding. Many downstream tasks require segmenting input text into meaningful constituent chunks (e.g., noun phrases or entities); more generally, models for learning semantic representations of text benefit from integrating syntax in the form of parse trees (e.g., treeLSTMs). Supervised parsers have traditionally been used to obtain these trees, but lately interest has increased in unsupervised methods that induce syntactic representations directly from unlabeled text. To this end, we propose the deep insideoutside recursive autoencoder (DIORA), a fully-unsupervised method for discovering syntax that simultaneously learns representations for constituents within the induced tree. Unlike many prior approaches, DIORA does not rely on supervision from auxiliary downstream tasks and is thus not constrained to particular domains. Furthermore, competing approaches do not learn explicit phrase representations along with tree structures, which limits their applicability to phrase-based tasks. Extensive experiments on unsupervised parsing, segmentation, and phrase clustering demonstrate the efficacy of our method. DIORA achieves the state of the art in unsupervised parsing (46.9 F1) on the benchmark WSJ dataset.
+
+# 1 INTRODUCTION
+
+Syntax in the form of parse trees is an essential component of many natural language processing tasks. Constituent spans taken from a parse tree are useful for tasks such as relation extraction Verga et al. (2016) and semantic role labeling (Strubell et al., 2018), while the full parse itself can be used to build higher-quality systems for machine translation (Aharoni and Goldberg, 2017) and text classification (Tai et al., 2015). Supervised parsers trained on datasets such as the Penn Treebank (Marcus et al., 1994) are traditionally used to obtain these trees; however, these datasets are generally small and restricted to the newswire domain. For out-of-domain applications, it is generally infeasible to create new treebanks, as syntactic annotation is expensive and time-consuming.
+
+Motivated by these limitations, we propose a method that extracts both shallow parses (i.e., noun phrases or entities) and full syntactic trees from any domain or language automatically without any training data. In addition to just producing the parse, we want our model to build representations for internal constituents that obey syntactic and semantic regularities, as we can then easily inject these representations into downstream tasks. Our model extends existing work on latent tree chart parsers (Le and Zuidema, 2015; Yogatama et al., 2016; Maillard et al., 2017; Choi et al., 2018), which build up representations for all internal nodes in the tree (cells in the chart) generated by a soft weighting over all possible sub-trees (Section 2).
+
+In previous work, the representation at the root node is used as a sentence encoding and trained to optimize some downstream task, typically natural language inference. Unfortunately, this method requires sentence level annotations to train the model. Worse still, analysis on the trees learned by these models show that they are actually quite poor at capturing syntax that in any way resembles linguistic theory (Williams et al., 2018a). To address these issues, we incorporate the inside-outside algorithm (Baker, 1979; Lari and Young, 1990) into a latent tree chart parser. The bottom-up inside step is equivalent to the forward-pass of previous latent tree chart parsers (Maillard et al., 2017). However, these inside representations are encoded by looking only within the current subtree, completely ignoring outside context. Thus, we perform an additional top-down outside calculation for each node in the tree incorporating external context into sub-tree representations. Finally, we train the outside representations of leaves to reconstruct the initial input, which results in a completely unsupervised autoencoder-like objective.
+
+![](images/257d72c4357292801b1451c12a1c400f9d36051fd62db8226b13f401c4123b5d.jpg)  
+Figure 1: Example parse trees. Top PRPN-LM prediction, bottom DIORA prediction. DIORA correctly chunks the span ‘raised hopes for further interest-rate cuts’.
+
+Recently, Shen et al. (2018) proposed Parsing-Reading-Predict Networks (PRPN), an RNN based language model with an additional module for inferring syntactic distance. After training, this syntax module can be decomposed to recover a parse (Htut et al., 2018) via a complex mechanism that involves modeling a distribution over possible syntactic structures with a stick-breaking process. Like DIORA, this model can be trained in a completely unsupervised manner. However, it has no mechanism of explicitly modeling phrases, and span representations can only be generated by post-hoc heuristics. Additionally, finding the most probable tree in DIORA is much simpler than in PRPN, as we can just run the CKY algorithm.
+
+To probe different properties of our model, we run experiments on unsupervised parsing, segmentation, and phrase representations. DIORA sets the state-of-the-art for unsupervised parsing on the WSJ dataset, has a greater recall on a more constituent types than PRPN, and demonstrates strong clustering of phrase representations.
+
+# 2 DIORA: DEEP INSIDE-OUTSIDE RECURSIVE AUTO-ENCODER
+
+Our goal is to build an unsupervised model which can automatically discover syntactic structure from raw text. The hypothesis that our model follows is that the most efficient compression of a sentence will be derived from following the true syntactic structure of the underlying input. Our model is an extension of latent tree chart parsers augmented with the inside-outside algorithm (Baker, 1979; Lari and Young, 1990) and trained as an auto-encoder. Based on our hypothesis, the auto-encoder will best reconstruct the input by discovering and exploiting syntactic regularities of the text.
+
+The inside phase of our method recursively compresses the input sequence into a single vector representing the sentence (Section 2.1.1). This is analogous to the compression step of an autoencoder and equivalent to existing latent tree chart parsers forward pass. Following this, we initiate the outside phase of our algorithm there a generic sentence (root) representation which is trained as a part of the model parameter. As an outside step of the inside-outside algorithm (Section 2.1.2), we expand outward until finally producing reconstructed representations of the leaf nodes. These reconstructed leaves are then optimized to reconstruct the input sentence as done in an auto-encoder based deep neural network (Section 2.2).
+
+# 2.1 FILLING THE CHART WITH INSIDE-OUTSIDE
+
+Each inside representation of a given sub-tree is built considering only the children constituents of that sub-tree, independent of any outside context. After the inside representations are calculated, we do a top-down outside pass to compute outside representations. The outside representations are encoded by looking at the context of a given sub-tree. In the end, each cell in the chart will contain an inside vector, inside compatibility score, outside vector, and outside compatibility score.
+
+Once the chart is filled, each constituent $k$ (cell in the chart) is associated with an inside vector $\alpha _ { k } ^ { v e c }$ , an outside vector $\beta _ { k } ^ { v e c }$ , inside score $\alpha _ { k } ^ { s c o r e }$ and outside score $\beta _ { k } ^ { s c o r e }$ .
+
+![](images/a8ac72f7bc5265dbe83dfc1cf63aefad38e0306a727add4fc17297782595aa7f.jpg)  
+Figure 2: The inside and outside pass of DIORA for the input ‘the cat drank milk’. a) The inside pass: The inside vector for the phrase ‘the cat drank’ is a weighted average of the compositions for the two possible segmentations - ((the cat), drank) and (the, (cat drank)). The weights come from the learned compatibility scores $\alpha _ { k } ^ { s c o r e }$ . b) The outside Pass: The outside vector for the phrase ‘drank milk’ is a function of the outside vector of its parent and the inside vector of its sibling.
+
+Assuming that the input to our model is a sentence $X$ made up of $T$ tokens, $x _ { 0 } , x _ { 1 } , . . . , x _ { T }$ , we describe inside and outside phases of our algorithm in the following Sections 2.1.1 and 2.1.2. Also, each token $x _ { i }$ has a corresponding pre-trained $d$ dimensional embedding vector $v _ { i }$ .
+
+# 2.1.1 INSIDE PHASE
+
+For each pair of neighboring constituents $i$ and $j$ , we compute a compatibility score $\alpha _ { k } ^ { s c o r e }$ and a composition vector $\alpha _ { k } ^ { v e c }$ . The score and vector that represents a particular span $k$ are computed using a soft weighting over all possible pairs of constituents that together covers the span entirely (we refer to this set of constituent pairs as $\{ k \} )$ :
+
+Vectors for spans of length 1 are initialized using a linear transformation of the embedded input $v _ { i }$ .   
+Scores associated with these spans are set to 0.
+
+$$
+\begin{array} { r } { \alpha _ { k } ^ { v e c } = W _ { i n } v _ { k } ^ { T } } \\ { \alpha _ { k } ^ { s c o r e } = 0 \qquad } \end{array}
+$$
+
+For higher levels of the chart we use:
+
+$$
+\begin{array} { c } { { \alpha _ { k } ^ { v e c } = \displaystyle \sum _ { i , j \in \{ k \} } e ^ { c o m p a t ( i , j ) } c o m p o s e ( i , j ) } } \\ { { \alpha _ { k } ^ { s c o r e } = \displaystyle \sum _ { i , j \in \{ k \} } e ^ { c o m p a t ( i , j ) } c o m p a t ( i , j ) } } \end{array}
+$$
+
+The compatibility function compat is a bilinear function of the vectors from neighboring spans, adding their scores:
+
+$$
+c o m p a t ( i , j ) = \alpha _ { i } ^ { v e c } S ^ { i n \top } \alpha _ { j } ^ { v e c \top } + \alpha _ { i } ^ { s c o r e } + \alpha _ { j } ^ { s c o r e }
+$$
+
+And the composition function compose is a TreeLSTM (Tai et al., 2015) which produces a hidden state vector $h$ and cell state vector $c$ .:
+
+$$
+c o m p o s e ( i , j ) = T r e e L S T M ^ { i n } ( \alpha _ { i } ^ { v e c } , \alpha _ { j } ^ { v e c } ) = \left[ h \right]
+$$
+
+Where the T reeLST M is defined as follows:
+
+$$
+\begin{array}{c} { \left[ \begin{array} { l } { i } \\ { f _ { i } } \\ { f _ { j } } \\ { u } \\ { o } \end{array} \right] } = { \left[ \begin{array} { l } { \sigma } \\ { \sigma } \\ { \sigma } \\ { \sigma } \\ { \operatorname { t a n h } } \end{array} \right] } \left( U \left[ h _ { i } \right] ^ { \top } + b + { \left[ \begin{array} { l } { 0 } \\ { \omega } \\ { \omega } \\ { h _ { j } } \end{array} \right] } \right)  \\ { c = c _ { i } \odot \sigma ( f _ { i } ) + c _ { j } \odot \sigma ( f _ { j } ) + \operatorname { t a n h } ( u ) \odot \sigma ( i ) } \\ { h = \sigma ( o ) + \operatorname { t a n h } ( c ) } \end{array} 
+$$
+
+The constant $\omega$ is set to 1 for the inside phase and 0 for the outside phase. The parameters $U$ and $b$ are not shared between the inside phase and outside phase.
+
+# 2.1.2 OUTSIDE PHASE
+
+The outside computation is similar to the inside,
+
+The root node of the outside chart is learned as a bias. Descendant cells are predicted using a disambiguation over the possible outside contexts. Each component of the context consists of a sibling cell from the inside chart and a parent cell from the outside chart.
+
+$$
+\begin{array} { c } { { \beta _ { k } ^ { v e c } = \displaystyle \sum _ { i , j \in \{ k \} } e ^ { d i s a m b ( i , j ) } p r e d i c t ( i , j ) } } \\ { { \beta _ { k } ^ { s c o r e } = \displaystyle \sum _ { i , j \in \{ k \} } e ^ { d i s a m b ( i , j ) } d i s a m b ( i , j ) } } \\ { { d i s a m b ( i , j ) = \beta _ { i } ^ { v e c } S ^ { o u t \top } \alpha _ { j } ^ { v e c \top } + \beta _ { i } ^ { s c o r e } + \alpha _ { j } ^ { s c o r e } } } \\ { { p r e d i c t ( i , j ) = T r e e L S T M ^ { o u t } ( \alpha _ { i } ^ { v e c } , \beta _ { j } ^ { v e c } ) } } \end{array}
+$$
+
+# 2.2 TRAINING OBJECTIVE
+
+To train our model we use an auto-encoder-like language modeling objective. In a standard autoencoder, the input $X$ is compressed into a single lower dimensional representation $Y$ . $Y$ is then decompressed and trained to predict $X$ . In our model, we never condition the reconstruction of $X$ on a single $Y$ because the root’s outside representation is initialized with a bias rather than the root’s own inside vector. Instead, we reconstruct $X$ conditioned on the many sub-tree roots, none of which is a single compression of the entire $X$ , but rather a subset.
+
+Each generated outside vector $\beta _ { i } ^ { v e c }$ for constituents of length 1 are trained to predict their original input $v _ { i }$ . We approximate a reconstruction loss with a max-margin across $N$ negative samples.
+
+For each $x _ { i }$ , we sample $N$ negative $\boldsymbol { x } _ { i } ^ { n }$ uniformly at random from the vocabulary. The training objective of our model over a batch $\mathbf { B } = \{ X _ { T ^ { i } } ^ { i } , i \stackrel { \cdot } { = } 1 , . . . , B \}$ is computed identically for all tokens (which are also all spans with length 1) within the batch and averaged to get the overall loss for the entire batch. Precisely, the loss function for each token (span k) is described in Equation 14.
+
+$$
+L ( \mathbf { B } ) = \sum _ { n = 1 } ^ { n = N } \operatorname* { m a x } ( 0 , 1 - \beta _ { k } ^ { v e c } * \alpha _ { k } ^ { v e c } + \beta _ { k } ^ { v e c } * \alpha _ { k _ { n } } ^ { v e c } )
+$$
+
+In equation 14, transformation, $\alpha _ { k _ { n } } ^ { v e c }$ are representations for negative samples from vocabulary. Similar to inputare also computed after applying a linear transformation over the input emnbeddings. As mentioned before, $\alpha _ { k } ^ { v e c }$ and $\beta _ { k } ^ { v e c }$ are inside and outside representations, for span k, respectively.
+
+Algorithm 1 Parsing with DIORA   
+
+<table><tr><td>1:</td><td>procedure CKY(chart)</td></tr><tr><td>2: for each k ∈chart|size(k)=1 do</td><td>Initialize terminal values.</td></tr><tr><td>3: 4:</td><td>xk←0</td></tr><tr><td>foreachk ∈chart do</td><td>Calculate a maximum score for each span.</td></tr><tr><td>5: 6:</td><td>xk ← max [xi +xj + compat(i,j)] i,j∈{k}</td></tr><tr><td>i,j∈{k}</td><td>bk ← arg max[xi + xj + compat(i,j)] &gt;Record a backpointer.</td></tr><tr><td>7:</td><td>procedure FOLLOW-BACKPOINTERS(k)</td></tr><tr><td>8:</td><td>if size(k)= 1 then</td></tr><tr><td>9: 10:</td><td>return k</td></tr><tr><td>11:</td><td>𝑖 ←FOLLOW-BACKPOINTERS(b)</td></tr><tr><td>12:</td><td>j ←FOLLOW-BACKPOINTERS(b)</td></tr><tr><td>return (i, j) 13:</td><td>return FOLLOW-BACKPOINTERS(k = root) &gt;Backtrack to get the maximal tree.</td></tr></table>
+
+# 2.3 DIORA CKY PARSING
+
+To obtain a parse with DIORA, we populate an inside and outside chart using the input sentence. Then, we can extract the most likely parse based on our single grammar rule using the CKY procedure (Kasami, 1966; Younger, 1967).
+
+It’s true that using CKY produces the most likely parse given a set of grammar rules, although in the case of DIORA, the single grammar rule is only a weak abstraction for a PCFG. For this reason, including context during CKY might inform our parser to make different decision. We include context by adding the scalar value of the outside cell to each inside cell.
+
+# 3 EXPERIMENTS
+
+To evaluate the effectiveness of DIORA, we run experiments on unsupervised parsing, unsupervised segmentation, and phrase similarities. The model has been implemented in PyTorch (Team, 2018) and the code is published online1. For implementation details, see the Appendix A.1
+
+Our main baseline is the current state-of-the-art unsupervised parser PRPN(Shen et al., 2018). We compare our model against two size variants of this model which were used in Htut et al. (2018). Comparison of the number of parameters and maximum training sentence length are shown in 1.
+
+Table 1: Model Dimensions.   
+
+<table><tr><td>Model</td><td>Word Dim</td><td>#Parameters</td><td>Max Length</td></tr><tr><td>DIORA</td><td>300</td><td>1,502,400</td><td>20</td></tr><tr><td>PRPN-UP</td><td>200</td><td>3,624,202</td><td>35</td></tr><tr><td>PRPN-LM</td><td>800</td><td>35,593,202</td><td>35</td></tr></table>
+
+# 3.1 UNSUPERVISED PARSING
+
+We first evaluate how well our model is able to predict a full unlabeled syntactic parse. We look at two data sets which have been used in prior work (Htut et al., 2018), The Wall Street Journal(WSJ) section of Penn Tree Bank (Marcus et al., 1994), and the automatic parses from MultiNLI (Williams et al., 2018b). WSJ has gold human annotated parses and MultiNLI contains automatic parses derived from the Stanford CoreNLP parser (Manning et al., 2014).
+
+We compare our model to left/right branching and balanced trees which are deterministically constructed. RL-SPINN (Yogatama et al., 2016) and ST-Gumbel (Choi et al., 2018) are chart parsing models trained to predict the downstream task of NLI.
+
+# 3.1.1 RESULTS AND DISCUSSION
+
+Latent tree models have been shown to perform particularly poorly on attachments at the beginning and end of the sequence (Williams et al., 2018a). To address this, we incorporate a post-processing heuristic $+ \mathrm { P P }$ in Table 2). We see that PRPN-UP and DIORA benefit much more than PRPN-LM from this heuristic. This is consistent with qualitative analysis showing that DIORA and PRPN-UP incorrectly attach trailing punctuation much more than PRPN-LM. This heuristic simply attaches trailing punctuation to the root of the tree, regardless of its predicted attachment. We find this to be extremely effective, increasing our state-of-the-art WSJ parsing results by by over 3 absolute F1 points.
+
+On the MultiNLI dataset, PRPN-LM is the top performing model without using the PP heuristic and DIORA outperforms PRPN-UP. Afterwards, PRPN-UP surpasses DIORA. However, it is worth noting that this is not actually a gold standard evaluation and instead evaluates the ability to replicate the output of a trained parser Manning et al. (2014).
+
+Table 2: Unsupervised Parsing. $\dagger$ indicates trained to optimize NLI task.We use the max unlabeled binary F1 across runs for PRPN-UP 2, PRPN-LM, and DIORA. F1 was calculated using the parse trees provided by Htut et al. (2018) and all results in the upper portion of the table were copied from Htut et al. (2018). $+ \mathrm { P P }$ refers to post-processing heuristic to remove trailing punctuation explained in Section 3.1.   
+
+<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>MultiNLIF1   Depth</td><td rowspan=2 colspan=1>WSJF1   Depth</td></tr><tr><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Left Branching</td><td rowspan=1 colspan=1>-       -</td><td rowspan=1 colspan=1>13.1   12.4</td></tr><tr><td rowspan=1 colspan=1>Right Branching</td><td rowspan=1 colspan=1>-       -</td><td rowspan=1 colspan=1>16.5   12.4</td></tr><tr><td rowspan=1 colspan=1>Random</td><td rowspan=1 colspan=1>27.0    4.4</td><td rowspan=1 colspan=1>21.4   5.3</td></tr><tr><td rowspan=1 colspan=1>Balanced</td><td rowspan=1 colspan=1>21.3    3.9</td><td rowspan=1 colspan=1>21.3   4.6</td></tr><tr><td rowspan=2 colspan=1>RL-SPINNt- w/o Leaf GRU</td><td rowspan=1 colspan=1>18.8    8.6</td><td rowspan=1 colspan=1>13.2     -</td></tr><tr><td rowspan=1 colspan=1>18.1    8.6</td><td rowspan=1 colspan=1>13.2     -</td></tr><tr><td rowspan=2 colspan=1>ST-Gumbelt - w/o Leaf GRU</td><td rowspan=1 colspan=1>23.7    4.1</td><td rowspan=1 colspan=1>20.1     1</td></tr><tr><td rowspan=1 colspan=1>27.5   4.6</td><td rowspan=1 colspan=1>25.0     -</td></tr><tr><td rowspan=1 colspan=1>PRPN-UP</td><td rowspan=1 colspan=1>48.4    4.9</td><td rowspan=2 colspan=1>40.6    5.943.5    6.2</td></tr><tr><td rowspan=1 colspan=1>PRPN-LM</td><td rowspan=1 colspan=1>50.2    5.0</td></tr><tr><td rowspan=1 colspan=1>DIORA</td><td rowspan=1 colspan=1>49.0    6.2</td><td rowspan=1 colspan=1>43.8    8.1</td></tr><tr><td rowspan=1 colspan=1>PRPN-UP+PP</td><td rowspan=1 colspan=1>54.6    4.9</td><td rowspan=1 colspan=1>46.1   5.9</td></tr><tr><td rowspan=1 colspan=1>PRPN-LM+PP</td><td rowspan=1 colspan=1>50.1    5.0</td><td rowspan=1 colspan=1>43.0    6.2</td></tr><tr><td rowspan=1 colspan=1>DIORA+PP</td><td rowspan=1 colspan=1>53.7    6.1</td><td rowspan=1 colspan=1>46.9   7.9</td></tr></table>
+
+# 3.2 UNSUPERVISED PHRASE SEGMENTATION
+
+In many scenarios, rather than a full parse, one is only concerned with extracting particular constituent phrases, such as entities, to be used for downstream analysis. In order to get an idea of how well our model can perform on phrase segmentation, we consider the maximum recall of spans in our predicted parse tree. We leave methods for cutting the tree to future work and instead consider the maximum recall of our model which serves as an upper bound on its performance. We calculate recall as the percentage of labeled constituents that appear in our predicted tree relative the total number of constituents in the gold tree. We separate these scores by type which are presented in Table 3.
+
+# 3.2.1 RESULTS AND DISCUSSION
+
+In Table 2 we see the breakdown of constituent recall across the 10 most common types. We see that PRPN-UP has the highest recall for the most common type noun-phrase, but drops in every other category. DIORA achieves the highest recall across the most types and is the only model to perform effectively on verb-phrases. However, DIORA performs poorly relative to PRPN at prepositional phrases.
+
+<table><tr><td>Label</td><td>Count</td><td>DIORA</td><td>PRPN-UP</td><td>PRPN-LM</td></tr><tr><td>NP</td><td>297,687</td><td>0.620</td><td>0.687</td><td>0.597</td></tr><tr><td>VP</td><td>168,603</td><td>0.569</td><td>0.397</td><td>0.316</td></tr><tr><td>PP</td><td>116,338</td><td>0.338</td><td>0.499</td><td>0.602</td></tr><tr><td>S</td><td>87,714</td><td>0.711</td><td>0.629</td><td>0.625</td></tr><tr><td>SBAR</td><td>24,743</td><td>0.490</td><td>0.412</td><td>0.554</td></tr><tr><td>ADJP</td><td>12,261</td><td>0.495</td><td>0.343</td><td>0.360</td></tr><tr><td>QP</td><td>11,441</td><td>0.624</td><td>0.336</td><td>0.545</td></tr><tr><td>ADVP</td><td>5,812</td><td>0.437</td><td>0.392</td><td>0.499</td></tr><tr><td>PRN</td><td>2,971</td><td>0.185</td><td>0.108</td><td>0.138</td></tr><tr><td>SINV</td><td>2,563</td><td>0.923</td><td>0.889</td><td>0.905</td></tr></table>
+
+Table 3: Segment recall from WSJ seperated by phrase type. The 10 most frequent phrase types are shown. Highest value in each row is bolded.
+
+# 3.3 PHRASE SIMILARITY
+
+One of the goals of DIORA is to learn meaningful representations for spans of text. Most language modeling methods focus only on explicitly modeling token representations and rely on ad-hoc post-processing to generate representations for longer spans, typically relying on simple arithmetic functions of the individual tokens.
+
+To evaluate our model’s learned phrase representations, we look at the similarity between spans of the same type within labeled phrase datasets. We look at two datasets, CoNLL 2000 is a shallow parsing dataset containing spans of noun phrases, verb phrases, etc. CoNLL 2012 is a named entity dataset containing 19 different entity types.
+
+For each of the labeled spans (greater than length 1) in the datasets, we generate a phrase representation and similarities are based on cosine distance. We report three numerical evaluations for both datasets precision $@ \mathrm { K }$ , mean average precision (MAP), and dendogram purity (DP). We run a hierarchical clustering algorithm over the representations and computeDP (Kobren et al., 2017). Given any two points with the same gold label, the clustering tree is cut to form the minimal cluster containing both points. DP then calculates how pure that cluster is.
+
+The first baseline we compare against produces phrase representations from averaging Glove vectors of the individual tokens within the span. The second uses ELMo (Peters et al., 2018a), a method for obtaining powerful, context dependent word embeddings that has led to many recent state-of-the-art results in NLP. We obtain phrases following the procedure described in (Peters et al., 2018b) and represent phrases as a function of its first and last hidden state. We look at two variants of $\mathrm { E L M o } ^ { 3 }$ . ELMo-L1 produces token hidden states by only taking the bottom LSTM layer outputs, ELMo-Avg takes a flat average over all of the LSTM hidden state layers4.
+
+# 3.3.1 RESULTS
+
+On the CoNLL 2000 dataset, we find that our model outperforms Glove and is competitive with ELMo. For CoNLL 2012, an named entity dataset, we find Glove to actually be the top performer
+
+under some metrics while our model is far behind. These results indicate that DIORA is capturing syntax quite well, but is currently missing semantics.
+
+<table><tr><td rowspan="2">Model</td><td rowspan="2">Dim</td><td colspan="4">CoNLL 2000</td><td colspan="4">CoNLL 2012</td></tr><tr><td>DP</td><td>P@10</td><td>P@100</td><td>MAP</td><td>DP</td><td>P@10</td><td>P@100</td><td>MAP</td></tr><tr><td>Random</td><td>300</td><td>0.425</td><td>0.41</td><td>0.40</td><td>0.34</td><td>0.16</td><td>0.15</td><td>0.14</td><td>0.13</td></tr><tr><td>Glove</td><td>300</td><td>0.521</td><td>0.89</td><td>0.74</td><td>0.53</td><td>0.392</td><td>0.82</td><td>0.65</td><td>0.47</td></tr><tr><td>ELMo-L1</td><td>4096</td><td>0.632</td><td>0.96</td><td>0.83</td><td>0.55</td><td>0.352</td><td>0.85</td><td>0.68</td><td>0.39</td></tr><tr><td>-L2</td><td>4096</td><td>0.545</td><td>0.94</td><td>0.79</td><td>0.57</td><td>0.301</td><td>0.83</td><td>0.67</td><td>0.39</td></tr><tr><td>- Concat</td><td>8192</td><td>0.576</td><td>0.95</td><td>0.78</td><td>0.58</td><td>0.308</td><td>0.84</td><td>0.68</td><td>0.40</td></tr><tr><td>- Avg</td><td>4096</td><td>0.618</td><td>0.97</td><td>0.84</td><td>0.67</td><td>0.369</td><td>0.87</td><td>0.73</td><td>0.46</td></tr><tr><td>DIORA-In</td><td>200</td><td>0.620</td><td>0.89</td><td>0.77</td><td>0.61</td><td>0.303</td><td>0.77</td><td>0.54</td><td>0.36</td></tr><tr><td>- Out</td><td>200</td><td>0.581</td><td>0.69</td><td>0.65</td><td>0.47</td><td>0.200</td><td>0.35</td><td>0.24</td><td>0.18</td></tr><tr><td>- In/Out</td><td>400</td><td>0.615</td><td>0.89</td><td>0.79</td><td>0.62</td><td>0.308</td><td>0.76</td><td>0.54</td><td>0.35</td></tr><tr><td>- In/Out Ext.</td><td>400</td><td>0.633</td><td>0.89</td><td>0.79</td><td>0.62</td><td>0.311</td><td>0.77</td><td>0.54</td><td>0.35</td></tr></table>
+
+Table 4: Dendogram purity, $\mathrm { P @ 1 0 }$ , $\mathrm { P } @ 1 0 0$ , and MAP for labeled chunks from CoNLL-2000 and CoNLL 2012 datasets. For both metrics, higher is better. The top value in each column is bolded, or italicized if it is better than our model.
+
+# 3.4 QUALITATIVE RESULTS
+
+We show example trees from PRPN-LM and DIORA in 3.
+
+# 4 RELATED WORK
+
+Latent Tree Learning A brief survey of neural latent tree learning models was covered in Williams et al. (2018a). The first positive result for latent tree was shown in Htut et al. (2018), which used a language modeling objective. The model in Liue et al. (2018) uses an inside chart and an outside procedure to calculate marginal probabilities use to align spans between sentences in entailment.
+
+Neural Inside-Outside Parsers The Inside-Outside Recursive Neural Network (IORNN) in Le and Zuidema (2014) is closest to ours and is a graph-based dependency parser that produces a $k$ -best list of parses, in contrast, DIORA produces the most likely parse given the learned the potential functions of the constituents. The Neural CRF Parser (Durrett and Klein, 2015), similar to DIORA, performs exact inference on the structure of a sentence, although requires a set of grammar rules and labeled parse trees during training. DIORA, like Liue et al. (2018), has a single grammar rule that applies to any pair of constituents and does not use structural supervision.
+
+Unsupervised Parsing and Segmentation Unsupervised segmentation (also called chunking) from raw text dates back to Ponvert et al. (2011). Another paper by the same authors (Ponvert et al., 2010) only looked at parsing certain low-level constituents. Earlier grammar induction models were evaluated against a subset of the WSJ treebank filtered to sentences of length 10 after removing punctuation (Klein and Manning, 2002; 2004) while DIORA is evaluated against two much larger datasets for unsupervised parsing, including the full WSJ treebank. Unsupervised segmentation with across parallel corpora was performed in Das and Petrov (2011). The source language had segment labels, the target language did not, but there are mapped translations between the two languages. Cohen et al. (2011) achieved unsupervised segmentation for parallel corpora without using mapped translations.
+
+# 5 CONCLUSION
+
+In this work we presented DIORA, a completely unsupervised method for inducing syntactic trees and segmentations over text. We showed that an auto encoder language modeling objective on top of inside-outside representations of latent tree chart parsers allows us to effectively learn syntactic structure of language. In experiments on unsupervised parsing, chunking, and phrase representations we show our model is comparable to or outperforms current baselines, achieving the state-of-the-art performance on unsupervised parsing for the WSJ dataset. .
+
+![](images/30ed060157b9659f2730798dcded6e376d991f624ef5b49674f2de5662f86fe4.jpg)  
+Figure 3: Pairs of example parses for the same sentence from two different models. For each pair, the top is the output of PRPN-LM and bottom was produced by DIORA. Bolden token pairs or spans indicate a parse error by PRPN that was correctly attached by DIORA. Some punctuation was removed for clarity of printed trees.
+
+Future work can improve the current method by training larger models over much larger corpora including other domains and languages. While the current model seems to focus primarily on syntax, extra unsupervised objectives or light supervision could be injected into the learning procedure to encourage a more thorough capturing of semantics.
+
+# REFERENCES
+
+Patrick Verga, David Belanger, Emma Strubell, Benjamin Roth, and Andrew McCallum. Multilingual relation extraction using compositional universal schema. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 886–896, San Diego, California, June 2016. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/N16-1103.
+
+Emma Strubell, Patrick Verga, Daniel Andor, David Weiss, and Andrew McCallum. LinguisticallyInformed Self-Attention for Semantic Role Labeling. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018.
+
+Roee Aharoni and Yoav Goldberg. Towards string-to-tree neural machine translation. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, 2017.
+
+Kai Sheng Tai, Richard Socher, and Christopher D. Manning. Improved semantic representations from tree-structured long short-term memory networks. In ACL, 2015.
+
+Mitchell Marcus, Grace Kim, Mary Ann Marcinkiewicz, Robert MacIntyre, Ann Bies, Mark Ferguson, Karen Katz, and Britta Schasberger. The penn treebank: annotating predicate argument structure. In Proceedings of the workshop on Human Language Technology, pages 114–119. Association for Computational Linguistics, 1994.
+
+Phong Le and Willem Zuidema. The forest convolutional network: Compositional distributional semantics with a neural chart and without binarization. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pages 1155–1164, 2015.
+
+Dani Yogatama, Phil Blunsom, Chris Dyer, Edward Grefenstette, and Wang Ling. Learning to compose words into sentences with reinforcement learning. arXiv preprint arXiv:1611.09100, 2016.
+
+Jean Maillard, Stephen Clark, and Dani Yogatama. Jointly learning sentence embeddings and syntax with unsupervised tree-lstms. arXiv preprint arXiv:1705.09189, 2017.
+
+Jihun Choi, Kang Min Yoo, and Sang-goo Lee. Learning to compose task-specific tree structures. In In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, New Orleans, Louisiana, USA, February 2-7, 2018, 2018.
+
+Adina Williams, Andrew Drozdov, and Samuel R Bowman. Do latent tree learning models identify meaningful structure in sentences? Transactions of the Association of Computational Linguistics, 6:253–267, 2018a.
+
+James K Baker. Trainable grammars for speech recognition. The Journal of the Acoustical Society of America, 65(S1):S132–S132, 1979.
+
+Karim Lari and Steve J Young. The estimation of stochastic context-free grammars using the insideoutside algorithm. Computer speech & language, 4(1):35–56, 1990.
+
+Yikang Shen, Zhouhan Lin, Chin-Wei Huang, and Aaron Courville. Neural language modeling by jointly learning syntax and lexicon. 2018.
+
+Phu Mon Htut, Kyunghyun Cho, and Samuel R Bowman. Grammar induction with neural language models: An unusual replication. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018.
+
+Tadao Kasami. An efficient recognition and syntax-analysis algorithm for context-free languages. Coordinated Science Laboratory Report no. R-257, 1966.
+
+Daniel H Younger. Recognition and parsing of context-free languages in time n3. Information and control, 10(2):189–208, 1967.
+
+Pytorch Core Team. Pytorch: Tensors and dynamic neural networks in python with strong gpu acceleration. http://pytorch.org/, 2018. Accessed: 2018-09-26.
+
+Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1112–1122. Association for Computational Linguistics, 2018b. URL http://aclweb.org/anthology/N18-1101.
+
+Christopher Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In Proceedings of 52nd annual meeting of the association for computational linguistics: system demonstrations, pages 55–60, 2014.
+
+Ari Kobren, Nicholas Monath, Akshay Krishnamurthy, and Andrew McCallum. A hierarchical algorithm for extreme clustering. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’17, pages 255–264, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4887-4. doi: 10.1145/3097983.3098079. URL http://doi.acm.org/10.1145/3097983.3098079.
+
+Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proc. of NAACL, 2018a.
+
+Matthew E Peters, Mark Neumann, Luke Zettlemoyer, and Wen-tau Yih. Dissecting contextual word embeddings: Architecture and representation. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018b.
+
+Yang Liue, Matt Gardner, and Mirella Lapata. Structured alignment networks. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018.
+
+Phong Le and Willem Zuidema. The inside-outside recursive neural network model for dependency parsing. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 729–739, 2014.
+
+Greg Durrett and Dan Klein. Neural crf parsing. In ACL, 2015.
+
+Elias Ponvert, Jason Baldridge, and Katrin Erk. Simple unsupervised grammar induction from raw text with cascaded finite state models. In ACL, 2011.
+
+Elias Ponvert, Jason Baldridge, and Katrin Erk. Simple unsupervised identification of low-level constituents. 2010 IEEE Fourth International Conference on Semantic Computing, pages 24–31, 2010.
+
+Dan Klein and Christopher D. Manning. A generative constituent-context model for improved grammar induction. In ACL, 2002.
+
+Dan Klein and Christopher D. Manning. Corpus-based induction of syntactic structure: Models of dependency and constituency. In ACL, 2004.
+
+Dipanjan Das and Slav Petrov. Unsupervised part-of-speech tagging with bilingual graph-based projections. In ACL, 2011.
+
+Shay B. Cohen, Dipanjan Das, and Noah A. Smith. Unsupervised structure prediction with nonparallel multilingual guidance. In EMNLP, 2011.
+
+Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 1532–1543, 2014.
+
+# A APPENDIX
+
+# A.1 TRAINING DETAILS
+
+All DIORA experiments are trained with these settings unless otherwise specified: we use the ALLNLI corpus including only sentences with length less than 20, stochastic gradient descent with a batch size of 256, and the model dimension set to 200. The input sentences are embedded using the 300D 480B GloVe embeddings (Pennington et al., 2014) and are not updated during training. Sentences are grouped into batches with uniform sentence length. Each cell in the chart has its L2- norm set to 1. Early stopping is done using the reconstruction objective evaluated on a held-out set. When depending on Noise Contrastive Estimation (as is the case in the reconstruction objective), we sample 3 negative examples per positive example.

parse/train/HJeq43AqF7/HJeq43AqF7_content_list.json

@@ -0,0 +1,1384 @@
+[
+    {
+        "type": "text",
+        "text": "UNSUPERVISED LATENT TREE INDUCTION WITH DEEP INSIDE-OUTSIDE RECURSIVE AUTO-ENCODERS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            98,
+            821,
+            146
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous authors Paper under double-blind review ",
+        "bbox": [
+            183,
+            170,
+            398,
+            198
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "ABSTRACT ",
+        "text_level": 1,
+        "bbox": [
+            454,
+            234,
+            544,
+            251
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Syntax is a powerful abstraction for language understanding. Many downstream tasks require segmenting input text into meaningful constituent chunks (e.g., noun phrases or entities); more generally, models for learning semantic representations of text benefit from integrating syntax in the form of parse trees (e.g., treeLSTMs). Supervised parsers have traditionally been used to obtain these trees, but lately interest has increased in unsupervised methods that induce syntactic representations directly from unlabeled text. To this end, we propose the deep insideoutside recursive autoencoder (DIORA), a fully-unsupervised method for discovering syntax that simultaneously learns representations for constituents within the induced tree. Unlike many prior approaches, DIORA does not rely on supervision from auxiliary downstream tasks and is thus not constrained to particular domains. Furthermore, competing approaches do not learn explicit phrase representations along with tree structures, which limits their applicability to phrase-based tasks. Extensive experiments on unsupervised parsing, segmentation, and phrase clustering demonstrate the efficacy of our method. DIORA achieves the state of the art in unsupervised parsing (46.9 F1) on the benchmark WSJ dataset. ",
+        "bbox": [
+            233,
+            267,
+            764,
+            489
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 INTRODUCTION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            516,
+            336,
+            532
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Syntax in the form of parse trees is an essential component of many natural language processing tasks. Constituent spans taken from a parse tree are useful for tasks such as relation extraction Verga et al. (2016) and semantic role labeling (Strubell et al., 2018), while the full parse itself can be used to build higher-quality systems for machine translation (Aharoni and Goldberg, 2017) and text classification (Tai et al., 2015). Supervised parsers trained on datasets such as the Penn Treebank (Marcus et al., 1994) are traditionally used to obtain these trees; however, these datasets are generally small and restricted to the newswire domain. For out-of-domain applications, it is generally infeasible to create new treebanks, as syntactic annotation is expensive and time-consuming. ",
+        "bbox": [
+            174,
+            547,
+            825,
+            659
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Motivated by these limitations, we propose a method that extracts both shallow parses (i.e., noun phrases or entities) and full syntactic trees from any domain or language automatically without any training data. In addition to just producing the parse, we want our model to build representations for internal constituents that obey syntactic and semantic regularities, as we can then easily inject these representations into downstream tasks. Our model extends existing work on latent tree chart parsers (Le and Zuidema, 2015; Yogatama et al., 2016; Maillard et al., 2017; Choi et al., 2018), which build up representations for all internal nodes in the tree (cells in the chart) generated by a soft weighting over all possible sub-trees (Section 2). ",
+        "bbox": [
+            174,
+            666,
+            825,
+            777
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "In previous work, the representation at the root node is used as a sentence encoding and trained to optimize some downstream task, typically natural language inference. Unfortunately, this method requires sentence level annotations to train the model. Worse still, analysis on the trees learned by these models show that they are actually quite poor at capturing syntax that in any way resembles linguistic theory (Williams et al., 2018a). To address these issues, we incorporate the inside-outside algorithm (Baker, 1979; Lari and Young, 1990) into a latent tree chart parser. The bottom-up inside step is equivalent to the forward-pass of previous latent tree chart parsers (Maillard et al., 2017). However, these inside representations are encoded by looking only within the current subtree, completely ignoring outside context. Thus, we perform an additional top-down outside calculation for each node in the tree incorporating external context into sub-tree representations. Finally, we train the outside representations of leaves to reconstruct the initial input, which results in a completely unsupervised autoencoder-like objective. ",
+        "bbox": [
+            174,
+            785,
+            825,
+            924
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "image",
+        "img_path": "images/257d72c4357292801b1451c12a1c400f9d36051fd62db8226b13f401c4123b5d.jpg",
+        "image_caption": [
+            "Figure 1: Example parse trees. Top PRPN-LM prediction, bottom DIORA prediction. DIORA correctly chunks the span ‘raised hopes for further interest-rate cuts’. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            284,
+            98,
+            717,
+            223
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            300,
+            821,
+            328
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Recently, Shen et al. (2018) proposed Parsing-Reading-Predict Networks (PRPN), an RNN based language model with an additional module for inferring syntactic distance. After training, this syntax module can be decomposed to recover a parse (Htut et al., 2018) via a complex mechanism that involves modeling a distribution over possible syntactic structures with a stick-breaking process. Like DIORA, this model can be trained in a completely unsupervised manner. However, it has no mechanism of explicitly modeling phrases, and span representations can only be generated by post-hoc heuristics. Additionally, finding the most probable tree in DIORA is much simpler than in PRPN, as we can just run the CKY algorithm. ",
+        "bbox": [
+            174,
+            335,
+            825,
+            446
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "To probe different properties of our model, we run experiments on unsupervised parsing, segmentation, and phrase representations. DIORA sets the state-of-the-art for unsupervised parsing on the WSJ dataset, has a greater recall on a more constituent types than PRPN, and demonstrates strong clustering of phrase representations. ",
+        "bbox": [
+            174,
+            454,
+            825,
+            510
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2 DIORA: DEEP INSIDE-OUTSIDE RECURSIVE AUTO-ENCODER ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            534,
+            722,
+            550
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Our goal is to build an unsupervised model which can automatically discover syntactic structure from raw text. The hypothesis that our model follows is that the most efficient compression of a sentence will be derived from following the true syntactic structure of the underlying input. Our model is an extension of latent tree chart parsers augmented with the inside-outside algorithm (Baker, 1979; Lari and Young, 1990) and trained as an auto-encoder. Based on our hypothesis, the auto-encoder will best reconstruct the input by discovering and exploiting syntactic regularities of the text. ",
+        "bbox": [
+            174,
+            568,
+            825,
+            651
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "The inside phase of our method recursively compresses the input sequence into a single vector representing the sentence (Section 2.1.1). This is analogous to the compression step of an autoencoder and equivalent to existing latent tree chart parsers forward pass. Following this, we initiate the outside phase of our algorithm there a generic sentence (root) representation which is trained as a part of the model parameter. As an outside step of the inside-outside algorithm (Section 2.1.2), we expand outward until finally producing reconstructed representations of the leaf nodes. These reconstructed leaves are then optimized to reconstruct the input sentence as done in an auto-encoder based deep neural network (Section 2.2). ",
+        "bbox": [
+            174,
+            659,
+            825,
+            770
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 FILLING THE CHART WITH INSIDE-OUTSIDE ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            791,
+            521,
+            805
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Each inside representation of a given sub-tree is built considering only the children constituents of that sub-tree, independent of any outside context. After the inside representations are calculated, we do a top-down outside pass to compute outside representations. The outside representations are encoded by looking at the context of a given sub-tree. In the end, each cell in the chart will contain an inside vector, inside compatibility score, outside vector, and outside compatibility score. ",
+        "bbox": [
+            174,
+            818,
+            825,
+            888
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "Once the chart is filled, each constituent $k$ (cell in the chart) is associated with an inside vector $\\alpha _ { k } ^ { v e c }$ , an outside vector $\\beta _ { k } ^ { v e c }$ , inside score $\\alpha _ { k } ^ { s c o r e }$ and outside score $\\beta _ { k } ^ { s c o r e }$ . ",
+        "bbox": [
+            174,
+            895,
+            821,
+            924
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "image",
+        "img_path": "images/a8ac72f7bc5265dbe83dfc1cf63aefad38e0306a727add4fc17297782595aa7f.jpg",
+        "image_caption": [
+            "Figure 2: The inside and outside pass of DIORA for the input ‘the cat drank milk’. a) The inside pass: The inside vector for the phrase ‘the cat drank’ is a weighted average of the compositions for the two possible segmentations - ((the cat), drank) and (the, (cat drank)). The weights come from the learned compatibility scores $\\alpha _ { k } ^ { s c o r e }$ . b) The outside Pass: The outside vector for the phrase ‘drank milk’ is a function of the outside vector of its parent and the inside vector of its sibling. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            186,
+            106,
+            774,
+            272
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Assuming that the input to our model is a sentence $X$ made up of $T$ tokens, $x _ { 0 } , x _ { 1 } , . . . , x _ { T }$ , we describe inside and outside phases of our algorithm in the following Sections 2.1.1 and 2.1.2. Also, each token $x _ { i }$ has a corresponding pre-trained $d$ dimensional embedding vector $v _ { i }$ . ",
+        "bbox": [
+            174,
+            381,
+            825,
+            422
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "2.1.1 INSIDE PHASE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            438,
+            330,
+            453
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For each pair of neighboring constituents $i$ and $j$ , we compute a compatibility score $\\alpha _ { k } ^ { s c o r e }$ and a composition vector $\\alpha _ { k } ^ { v e c }$ . The score and vector that represents a particular span $k$ are computed using a soft weighting over all possible pairs of constituents that together covers the span entirely (we refer to this set of constituent pairs as $\\{ k \\} )$ : ",
+        "bbox": [
+            174,
+            462,
+            825,
+            518
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Vectors for spans of length 1 are initialized using a linear transformation of the embedded input $v _ { i }$ .   \nScores associated with these spans are set to 0. ",
+        "bbox": [
+            173,
+            525,
+            823,
+            554
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/a8b5681fdb928b061ae9de1b599c200822b66fc56df120b545810d8ce175636d.jpg",
+        "text": "$$\n\\begin{array} { r } { \\alpha _ { k } ^ { v e c } = W _ { i n } v _ { k } ^ { T } } \\\\ { \\alpha _ { k } ^ { s c o r e } = 0 \\qquad } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            441,
+            560,
+            557,
+            598
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "For higher levels of the chart we use: ",
+        "bbox": [
+            173,
+            611,
+            416,
+            626
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e1fc6b578538ecdab318d74c26e219046fbf8b7dd3648dc20f66cc73ff78a6bd.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\alpha _ { k } ^ { v e c } = \\displaystyle \\sum _ { i , j \\in \\{ k \\} } e ^ { c o m p a t ( i , j ) } c o m p o s e ( i , j ) } } \\\\ { { \\alpha _ { k } ^ { s c o r e } = \\displaystyle \\sum _ { i , j \\in \\{ k \\} } e ^ { c o m p a t ( i , j ) } c o m p a t ( i , j ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            356,
+            631,
+            640,
+            707
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "The compatibility function compat is a bilinear function of the vectors from neighboring spans, adding their scores: ",
+        "bbox": [
+            173,
+            719,
+            825,
+            747
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3e08678dd9d99a1925a85f034cdc17870ce017c7cc650f8b93ae633b5d376bbb.jpg",
+        "text": "$$\nc o m p a t ( i , j ) = \\alpha _ { i } ^ { v e c } S ^ { i n \\top } \\alpha _ { j } ^ { v e c \\top } + \\alpha _ { i } ^ { s c o r e } + \\alpha _ { j } ^ { s c o r e }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            773,
+            669,
+            795
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "And the composition function compose is a TreeLSTM (Tai et al., 2015) which produces a hidden state vector $h$ and cell state vector $c$ .: ",
+        "bbox": [
+            176,
+            806,
+            823,
+            835
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cc015c7f0dc77855f9dc91151add750f20b4e3938ad675c42a6e7aa8b551cd8e.jpg",
+        "text": "$$\nc o m p o s e ( i , j ) = T r e e L S T M ^ { i n } ( \\alpha _ { i } ^ { v e c } , \\alpha _ { j } ^ { v e c } ) = \\left[ h \\right]\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            861,
+            673,
+            896
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "Where the T reeLST M is defined as follows: ",
+        "bbox": [
+            174,
+            909,
+            475,
+            924
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/e378ed4e5999a0a826e0131e4535c6d664083ed97b8b02c62db12e7ec5be6a1c.jpg",
+        "text": "$$\n\\begin{array}{c} { \\left[ \\begin{array} { l } { i } \\\\ { f _ { i } } \\\\ { f _ { j } } \\\\ { u } \\\\ { o } \\end{array} \\right] } = { \\left[ \\begin{array} { l } { \\sigma } \\\\ { \\sigma } \\\\ { \\sigma } \\\\ { \\sigma } \\\\ { \\operatorname { t a n h } } \\end{array} \\right] } \\left( U \\left[ h _ { i } \\right] ^ { \\top } + b + { \\left[ \\begin{array} { l } { 0 } \\\\ { \\omega } \\\\ { \\omega } \\\\ { h _ { j } } \\end{array} \\right] } \\right)  \\\\ { c = c _ { i } \\odot \\sigma ( f _ { i } ) + c _ { j } \\odot \\sigma ( f _ { j } ) + \\operatorname { t a n h } ( u ) \\odot \\sigma ( i ) } \\\\ { h = \\sigma ( o ) + \\operatorname { t a n h } ( c ) } \\end{array} \n$$",
+        "text_format": "latex",
+        "bbox": [
+            326,
+            127,
+            671,
+            239
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The constant $\\omega$ is set to 1 for the inside phase and 0 for the outside phase. The parameters $U$ and $b$ are not shared between the inside phase and outside phase. ",
+        "bbox": [
+            173,
+            256,
+            825,
+            286
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.1.2 OUTSIDE PHASE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            306,
+            344,
+            321
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The outside computation is similar to the inside, ",
+        "bbox": [
+            176,
+            333,
+            490,
+            348
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "The root node of the outside chart is learned as a bias. Descendant cells are predicted using a disambiguation over the possible outside contexts. Each component of the context consists of a sibling cell from the inside chart and a parent cell from the outside chart. ",
+        "bbox": [
+            174,
+            356,
+            825,
+            397
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/d84ad192a364bce39e2fdb1f94929687ac03737b11db4f3c519a1c3ff61931d0.jpg",
+        "text": "$$\n\\begin{array} { c } { { \\beta _ { k } ^ { v e c } = \\displaystyle \\sum _ { i , j \\in \\{ k \\} } e ^ { d i s a m b ( i , j ) } p r e d i c t ( i , j ) } } \\\\ { { \\beta _ { k } ^ { s c o r e } = \\displaystyle \\sum _ { i , j \\in \\{ k \\} } e ^ { d i s a m b ( i , j ) } d i s a m b ( i , j ) } } \\\\ { { d i s a m b ( i , j ) = \\beta _ { i } ^ { v e c } S ^ { o u t \\top } \\alpha _ { j } ^ { v e c \\top } + \\beta _ { i } ^ { s c o r e } + \\alpha _ { j } ^ { s c o r e } } } \\\\ { { p r e d i c t ( i , j ) = T r e e L S T M ^ { o u t } ( \\alpha _ { i } ^ { v e c } , \\beta _ { j } ^ { v e c } ) } } \\end{array}\n$$",
+        "text_format": "latex",
+        "bbox": [
+            325,
+            428,
+            671,
+            545
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.2 TRAINING OBJECTIVE ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            564,
+            370,
+            579
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "To train our model we use an auto-encoder-like language modeling objective. In a standard autoencoder, the input $X$ is compressed into a single lower dimensional representation $Y$ . $Y$ is then decompressed and trained to predict $X$ . In our model, we never condition the reconstruction of $X$ on a single $Y$ because the root’s outside representation is initialized with a bias rather than the root’s own inside vector. Instead, we reconstruct $X$ conditioned on the many sub-tree roots, none of which is a single compression of the entire $X$ , but rather a subset. ",
+        "bbox": [
+            173,
+            592,
+            825,
+            676
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "Each generated outside vector $\\beta _ { i } ^ { v e c }$ for constituents of length 1 are trained to predict their original input $v _ { i }$ . We approximate a reconstruction loss with a max-margin across $N$ negative samples. ",
+        "bbox": [
+            174,
+            683,
+            823,
+            712
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "For each $x _ { i }$ , we sample $N$ negative $\\boldsymbol { x } _ { i } ^ { n }$ uniformly at random from the vocabulary. The training objective of our model over a batch $\\mathbf { B } = \\{ X _ { T ^ { i } } ^ { i } , i \\stackrel { \\cdot } { = } 1 , . . . , B \\}$ is computed identically for all tokens (which are also all spans with length 1) within the batch and averaged to get the overall loss for the entire batch. Precisely, the loss function for each token (span k) is described in Equation 14. ",
+        "bbox": [
+            174,
+            718,
+            825,
+            775
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/bd2f7a62a9e3174011edb7342f467e2a6b34f6e22591e9162aed0ddb84b9a9bd.jpg",
+        "text": "$$\nL ( \\mathbf { B } ) = \\sum _ { n = 1 } ^ { n = N } \\operatorname* { m a x } ( 0 , 1 - \\beta _ { k } ^ { v e c } * \\alpha _ { k } ^ { v e c } + \\beta _ { k } ^ { v e c } * \\alpha _ { k _ { n } } ^ { v e c } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            323,
+            804,
+            674,
+            849
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "In equation 14, transformation, $\\alpha _ { k _ { n } } ^ { v e c }$ are representations for negative samples from vocabulary. Similar to inputare also computed after applying a linear transformation over the input emnbeddings. As mentioned before, $\\alpha _ { k } ^ { v e c }$ and $\\beta _ { k } ^ { v e c }$ are inside and outside representations, for span k, respectively. ",
+        "bbox": [
+            174,
+            867,
+            825,
+            924
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/243c035d26ab40786f0806d8a7eac3ed766fd704432d43ab53dd3b7e4de19af5.jpg",
+        "table_caption": [
+            "Algorithm 1 Parsing with DIORA "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>1:</td><td>procedure CKY(chart)</td></tr><tr><td>2: for each k ∈chart|size(k)=1 do</td><td>Initialize terminal values.</td></tr><tr><td>3: 4:</td><td>xk←0</td></tr><tr><td>foreachk ∈chart do</td><td>Calculate a maximum score for each span.</td></tr><tr><td>5: 6:</td><td>xk ← max [xi +xj + compat(i,j)] i,j∈{k}</td></tr><tr><td>i,j∈{k}</td><td>bk ← arg max[xi + xj + compat(i,j)] &gt;Record a backpointer.</td></tr><tr><td>7:</td><td>procedure FOLLOW-BACKPOINTERS(k)</td></tr><tr><td>8:</td><td>if size(k)= 1 then</td></tr><tr><td>9: 10:</td><td>return k</td></tr><tr><td>11:</td><td>𝑖 ←FOLLOW-BACKPOINTERS(b)</td></tr><tr><td>12:</td><td>j ←FOLLOW-BACKPOINTERS(b)</td></tr><tr><td>return (i, j) 13:</td><td>return FOLLOW-BACKPOINTERS(k = root) &gt;Backtrack to get the maximal tree.</td></tr></table>",
+        "bbox": [
+            178,
+            116,
+            826,
+            340
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "2.3 DIORA CKY PARSING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            368,
+            379,
+            383
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To obtain a parse with DIORA, we populate an inside and outside chart using the input sentence. Then, we can extract the most likely parse based on our single grammar rule using the CKY procedure (Kasami, 1966; Younger, 1967). ",
+        "bbox": [
+            174,
+            396,
+            823,
+            439
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "It’s true that using CKY produces the most likely parse given a set of grammar rules, although in the case of DIORA, the single grammar rule is only a weak abstraction for a PCFG. For this reason, including context during CKY might inform our parser to make different decision. We include context by adding the scalar value of the outside cell to each inside cell. ",
+        "bbox": [
+            174,
+            445,
+            825,
+            502
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3 EXPERIMENTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            526,
+            326,
+            541
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "To evaluate the effectiveness of DIORA, we run experiments on unsupervised parsing, unsupervised segmentation, and phrase similarities. The model has been implemented in PyTorch (Team, 2018) and the code is published online1. For implementation details, see the Appendix A.1 ",
+        "bbox": [
+            174,
+            559,
+            825,
+            602
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "Our main baseline is the current state-of-the-art unsupervised parser PRPN(Shen et al., 2018). We compare our model against two size variants of this model which were used in Htut et al. (2018). Comparison of the number of parameters and maximum training sentence length are shown in 1. ",
+        "bbox": [
+            174,
+            609,
+            823,
+            651
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "table",
+        "img_path": "images/895994f1ba00ddb07699230fbe93190af5ed8d0cfddb903232a0b9070a30380e.jpg",
+        "table_caption": [
+            "Table 1: Model Dimensions. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Word Dim</td><td>#Parameters</td><td>Max Length</td></tr><tr><td>DIORA</td><td>300</td><td>1,502,400</td><td>20</td></tr><tr><td>PRPN-UP</td><td>200</td><td>3,624,202</td><td>35</td></tr><tr><td>PRPN-LM</td><td>800</td><td>35,593,202</td><td>35</td></tr></table>",
+        "bbox": [
+            303,
+            667,
+            687,
+            738
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "3.1 UNSUPERVISED PARSING ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            795,
+            390,
+            810
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We first evaluate how well our model is able to predict a full unlabeled syntactic parse. We look at two data sets which have been used in prior work (Htut et al., 2018), The Wall Street Journal(WSJ) section of Penn Tree Bank (Marcus et al., 1994), and the automatic parses from MultiNLI (Williams et al., 2018b). WSJ has gold human annotated parses and MultiNLI contains automatic parses derived from the Stanford CoreNLP parser (Manning et al., 2014). ",
+        "bbox": [
+            173,
+            823,
+            825,
+            892
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "We compare our model to left/right branching and balanced trees which are deterministically constructed. RL-SPINN (Yogatama et al., 2016) and ST-Gumbel (Choi et al., 2018) are chart parsing models trained to predict the downstream task of NLI. ",
+        "bbox": [
+            176,
+            103,
+            823,
+            146
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.1.1 RESULTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            169,
+            416,
+            183
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Latent tree models have been shown to perform particularly poorly on attachments at the beginning and end of the sequence (Williams et al., 2018a). To address this, we incorporate a post-processing heuristic $+ \\mathrm { P P }$ in Table 2). We see that PRPN-UP and DIORA benefit much more than PRPN-LM from this heuristic. This is consistent with qualitative analysis showing that DIORA and PRPN-UP incorrectly attach trailing punctuation much more than PRPN-LM. This heuristic simply attaches trailing punctuation to the root of the tree, regardless of its predicted attachment. We find this to be extremely effective, increasing our state-of-the-art WSJ parsing results by by over 3 absolute F1 points. ",
+        "bbox": [
+            174,
+            195,
+            825,
+            308
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "On the MultiNLI dataset, PRPN-LM is the top performing model without using the PP heuristic and DIORA outperforms PRPN-UP. Afterwards, PRPN-UP surpasses DIORA. However, it is worth noting that this is not actually a gold standard evaluation and instead evaluates the ability to replicate the output of a trained parser Manning et al. (2014). ",
+        "bbox": [
+            174,
+            314,
+            823,
+            371
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/c2c9d041c23c59ac9f54b041afb44f64b71279c7c338cd713e6750499b1b249c.jpg",
+        "table_caption": [
+            "Table 2: Unsupervised Parsing. $\\dagger$ indicates trained to optimize NLI task.We use the max unlabeled binary F1 across runs for PRPN-UP 2, PRPN-LM, and DIORA. F1 was calculated using the parse trees provided by Htut et al. (2018) and all results in the upper portion of the table were copied from Htut et al. (2018). $+ \\mathrm { P P }$ refers to post-processing heuristic to remove trailing punctuation explained in Section 3.1. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=2 colspan=1>Model</td><td rowspan=2 colspan=1>MultiNLIF1   Depth</td><td rowspan=2 colspan=1>WSJF1   Depth</td></tr><tr><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>Left Branching</td><td rowspan=1 colspan=1>-       -</td><td rowspan=1 colspan=1>13.1   12.4</td></tr><tr><td rowspan=1 colspan=1>Right Branching</td><td rowspan=1 colspan=1>-       -</td><td rowspan=1 colspan=1>16.5   12.4</td></tr><tr><td rowspan=1 colspan=1>Random</td><td rowspan=1 colspan=1>27.0    4.4</td><td rowspan=1 colspan=1>21.4   5.3</td></tr><tr><td rowspan=1 colspan=1>Balanced</td><td rowspan=1 colspan=1>21.3    3.9</td><td rowspan=1 colspan=1>21.3   4.6</td></tr><tr><td rowspan=2 colspan=1>RL-SPINNt- w/o Leaf GRU</td><td rowspan=1 colspan=1>18.8    8.6</td><td rowspan=1 colspan=1>13.2     -</td></tr><tr><td rowspan=1 colspan=1>18.1    8.6</td><td rowspan=1 colspan=1>13.2     -</td></tr><tr><td rowspan=2 colspan=1>ST-Gumbelt - w/o Leaf GRU</td><td rowspan=1 colspan=1>23.7    4.1</td><td rowspan=1 colspan=1>20.1     1</td></tr><tr><td rowspan=1 colspan=1>27.5   4.6</td><td rowspan=1 colspan=1>25.0     -</td></tr><tr><td rowspan=1 colspan=1>PRPN-UP</td><td rowspan=1 colspan=1>48.4    4.9</td><td rowspan=2 colspan=1>40.6    5.943.5    6.2</td></tr><tr><td rowspan=1 colspan=1>PRPN-LM</td><td rowspan=1 colspan=1>50.2    5.0</td></tr><tr><td rowspan=1 colspan=1>DIORA</td><td rowspan=1 colspan=1>49.0    6.2</td><td rowspan=1 colspan=1>43.8    8.1</td></tr><tr><td rowspan=1 colspan=1>PRPN-UP+PP</td><td rowspan=1 colspan=1>54.6    4.9</td><td rowspan=1 colspan=1>46.1   5.9</td></tr><tr><td rowspan=1 colspan=1>PRPN-LM+PP</td><td rowspan=1 colspan=1>50.1    5.0</td><td rowspan=1 colspan=1>43.0    6.2</td></tr><tr><td rowspan=1 colspan=1>DIORA+PP</td><td rowspan=1 colspan=1>53.7    6.1</td><td rowspan=1 colspan=1>46.9   7.9</td></tr></table>",
+        "bbox": [
+            320,
+            388,
+            674,
+            662
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 UNSUPERVISED PHRASE SEGMENTATION ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            784,
+            500,
+            797
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In many scenarios, rather than a full parse, one is only concerned with extracting particular constituent phrases, such as entities, to be used for downstream analysis. In order to get an idea of how well our model can perform on phrase segmentation, we consider the maximum recall of spans in our predicted parse tree. We leave methods for cutting the tree to future work and instead consider the maximum recall of our model which serves as an upper bound on its performance. We calculate recall as the percentage of labeled constituents that appear in our predicted tree relative the total number of constituents in the gold tree. We separate these scores by type which are presented in Table 3. ",
+        "bbox": [
+            174,
+            811,
+            825,
+            924
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2.1 RESULTS AND DISCUSSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            103,
+            418,
+            118
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In Table 2 we see the breakdown of constituent recall across the 10 most common types. We see that PRPN-UP has the highest recall for the most common type noun-phrase, but drops in every other category. DIORA achieves the highest recall across the most types and is the only model to perform effectively on verb-phrases. However, DIORA performs poorly relative to PRPN at prepositional phrases. ",
+        "bbox": [
+            174,
+            127,
+            823,
+            198
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/71b6a743592131239466f85127a2097e2a82112439e95775cf26ff7b356dd44d.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 3: Segment recall from WSJ seperated by phrase type. The 10 most frequent phrase types are shown. Highest value in each row is bolded. "
+        ],
+        "table_body": "<table><tr><td>Label</td><td>Count</td><td>DIORA</td><td>PRPN-UP</td><td>PRPN-LM</td></tr><tr><td>NP</td><td>297,687</td><td>0.620</td><td>0.687</td><td>0.597</td></tr><tr><td>VP</td><td>168,603</td><td>0.569</td><td>0.397</td><td>0.316</td></tr><tr><td>PP</td><td>116,338</td><td>0.338</td><td>0.499</td><td>0.602</td></tr><tr><td>S</td><td>87,714</td><td>0.711</td><td>0.629</td><td>0.625</td></tr><tr><td>SBAR</td><td>24,743</td><td>0.490</td><td>0.412</td><td>0.554</td></tr><tr><td>ADJP</td><td>12,261</td><td>0.495</td><td>0.343</td><td>0.360</td></tr><tr><td>QP</td><td>11,441</td><td>0.624</td><td>0.336</td><td>0.545</td></tr><tr><td>ADVP</td><td>5,812</td><td>0.437</td><td>0.392</td><td>0.499</td></tr><tr><td>PRN</td><td>2,971</td><td>0.185</td><td>0.108</td><td>0.138</td></tr><tr><td>SINV</td><td>2,563</td><td>0.923</td><td>0.889</td><td>0.905</td></tr></table>",
+        "bbox": [
+            303,
+            210,
+            691,
+            398
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 PHRASE SIMILARITY ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            464,
+            359,
+            478
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "One of the goals of DIORA is to learn meaningful representations for spans of text. Most language modeling methods focus only on explicitly modeling token representations and rely on ad-hoc post-processing to generate representations for longer spans, typically relying on simple arithmetic functions of the individual tokens. ",
+        "bbox": [
+            174,
+            491,
+            825,
+            546
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "To evaluate our model’s learned phrase representations, we look at the similarity between spans of the same type within labeled phrase datasets. We look at two datasets, CoNLL 2000 is a shallow parsing dataset containing spans of noun phrases, verb phrases, etc. CoNLL 2012 is a named entity dataset containing 19 different entity types. ",
+        "bbox": [
+            174,
+            554,
+            823,
+            609
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "For each of the labeled spans (greater than length 1) in the datasets, we generate a phrase representation and similarities are based on cosine distance. We report three numerical evaluations for both datasets precision $@ \\mathrm { K }$ , mean average precision (MAP), and dendogram purity (DP). We run a hierarchical clustering algorithm over the representations and computeDP (Kobren et al., 2017). Given any two points with the same gold label, the clustering tree is cut to form the minimal cluster containing both points. DP then calculates how pure that cluster is. ",
+        "bbox": [
+            173,
+            616,
+            825,
+            700
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "The first baseline we compare against produces phrase representations from averaging Glove vectors of the individual tokens within the span. The second uses ELMo (Peters et al., 2018a), a method for obtaining powerful, context dependent word embeddings that has led to many recent state-of-the-art results in NLP. We obtain phrases following the procedure described in (Peters et al., 2018b) and represent phrases as a function of its first and last hidden state. We look at two variants of $\\mathrm { E L M o } ^ { 3 }$ . ELMo-L1 produces token hidden states by only taking the bottom LSTM layer outputs, ELMo-Avg takes a flat average over all of the LSTM hidden state layers4. ",
+        "bbox": [
+            174,
+            707,
+            825,
+            804
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3.1 RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            820,
+            292,
+            834
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "On the CoNLL 2000 dataset, we find that our model outperforms Glove and is competitive with ELMo. For CoNLL 2012, an named entity dataset, we find Glove to actually be the top performer ",
+        "bbox": [
+            176,
+            844,
+            821,
+            873
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "under some metrics while our model is far behind. These results indicate that DIORA is capturing syntax quite well, but is currently missing semantics. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/b81a20c6c9e4dc57be04ed63f822e5e3b3dba912b448007780cd65d779ce5786.jpg",
+        "table_caption": [],
+        "table_footnote": [
+            "Table 4: Dendogram purity, $\\mathrm { P @ 1 0 }$ , $\\mathrm { P } @ 1 0 0$ , and MAP for labeled chunks from CoNLL-2000 and CoNLL 2012 datasets. For both metrics, higher is better. The top value in each column is bolded, or italicized if it is better than our model. "
+        ],
+        "table_body": "<table><tr><td rowspan=\"2\">Model</td><td rowspan=\"2\">Dim</td><td colspan=\"4\">CoNLL 2000</td><td colspan=\"4\">CoNLL 2012</td></tr><tr><td>DP</td><td>P@10</td><td>P@100</td><td>MAP</td><td>DP</td><td>P@10</td><td>P@100</td><td>MAP</td></tr><tr><td>Random</td><td>300</td><td>0.425</td><td>0.41</td><td>0.40</td><td>0.34</td><td>0.16</td><td>0.15</td><td>0.14</td><td>0.13</td></tr><tr><td>Glove</td><td>300</td><td>0.521</td><td>0.89</td><td>0.74</td><td>0.53</td><td>0.392</td><td>0.82</td><td>0.65</td><td>0.47</td></tr><tr><td>ELMo-L1</td><td>4096</td><td>0.632</td><td>0.96</td><td>0.83</td><td>0.55</td><td>0.352</td><td>0.85</td><td>0.68</td><td>0.39</td></tr><tr><td>-L2</td><td>4096</td><td>0.545</td><td>0.94</td><td>0.79</td><td>0.57</td><td>0.301</td><td>0.83</td><td>0.67</td><td>0.39</td></tr><tr><td>- Concat</td><td>8192</td><td>0.576</td><td>0.95</td><td>0.78</td><td>0.58</td><td>0.308</td><td>0.84</td><td>0.68</td><td>0.40</td></tr><tr><td>- Avg</td><td>4096</td><td>0.618</td><td>0.97</td><td>0.84</td><td>0.67</td><td>0.369</td><td>0.87</td><td>0.73</td><td>0.46</td></tr><tr><td>DIORA-In</td><td>200</td><td>0.620</td><td>0.89</td><td>0.77</td><td>0.61</td><td>0.303</td><td>0.77</td><td>0.54</td><td>0.36</td></tr><tr><td>- Out</td><td>200</td><td>0.581</td><td>0.69</td><td>0.65</td><td>0.47</td><td>0.200</td><td>0.35</td><td>0.24</td><td>0.18</td></tr><tr><td>- In/Out</td><td>400</td><td>0.615</td><td>0.89</td><td>0.79</td><td>0.62</td><td>0.308</td><td>0.76</td><td>0.54</td><td>0.35</td></tr><tr><td>- In/Out Ext.</td><td>400</td><td>0.633</td><td>0.89</td><td>0.79</td><td>0.62</td><td>0.311</td><td>0.77</td><td>0.54</td><td>0.35</td></tr></table>",
+        "bbox": [
+            174,
+            145,
+            825,
+            351
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "3.4 QUALITATIVE RESULTS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            431,
+            379,
+            445
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "We show example trees from PRPN-LM and DIORA in 3. ",
+        "bbox": [
+            176,
+            457,
+            555,
+            472
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4 RELATED WORK ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            491,
+            344,
+            507
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Latent Tree Learning A brief survey of neural latent tree learning models was covered in Williams et al. (2018a). The first positive result for latent tree was shown in Htut et al. (2018), which used a language modeling objective. The model in Liue et al. (2018) uses an inside chart and an outside procedure to calculate marginal probabilities use to align spans between sentences in entailment. ",
+        "bbox": [
+            174,
+            523,
+            825,
+            579
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Neural Inside-Outside Parsers The Inside-Outside Recursive Neural Network (IORNN) in Le and Zuidema (2014) is closest to ours and is a graph-based dependency parser that produces a $k$ -best list of parses, in contrast, DIORA produces the most likely parse given the learned the potential functions of the constituents. The Neural CRF Parser (Durrett and Klein, 2015), similar to DIORA, performs exact inference on the structure of a sentence, although requires a set of grammar rules and labeled parse trees during training. DIORA, like Liue et al. (2018), has a single grammar rule that applies to any pair of constituents and does not use structural supervision. ",
+        "bbox": [
+            174,
+            585,
+            825,
+            684
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "Unsupervised Parsing and Segmentation Unsupervised segmentation (also called chunking) from raw text dates back to Ponvert et al. (2011). Another paper by the same authors (Ponvert et al., 2010) only looked at parsing certain low-level constituents. Earlier grammar induction models were evaluated against a subset of the WSJ treebank filtered to sentences of length 10 after removing punctuation (Klein and Manning, 2002; 2004) while DIORA is evaluated against two much larger datasets for unsupervised parsing, including the full WSJ treebank. Unsupervised segmentation with across parallel corpora was performed in Das and Petrov (2011). The source language had segment labels, the target language did not, but there are mapped translations between the two languages. Cohen et al. (2011) achieved unsupervised segmentation for parallel corpora without using mapped translations. ",
+        "bbox": [
+            174,
+            690,
+            825,
+            829
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "5 CONCLUSION ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            849,
+            318,
+            866
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we presented DIORA, a completely unsupervised method for inducing syntactic trees and segmentations over text. We showed that an auto encoder language modeling objective on top of inside-outside representations of latent tree chart parsers allows us to effectively learn syntactic structure of language. In experiments on unsupervised parsing, chunking, and phrase representations we show our model is comparable to or outperforms current baselines, achieving the state-of-the-art performance on unsupervised parsing for the WSJ dataset. . ",
+        "bbox": [
+            176,
+            882,
+            823,
+            922
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "image",
+        "img_path": "images/30ed060157b9659f2730798dcded6e376d991f624ef5b49674f2de5662f86fe4.jpg",
+        "image_caption": [
+            "Figure 3: Pairs of example parses for the same sentence from two different models. For each pair, the top is the output of PRPN-LM and bottom was produced by DIORA. Bolden token pairs or spans indicate a parse error by PRPN that was correctly attached by DIORA. Some punctuation was removed for clarity of printed trees. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            94,
+            792,
+            498
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            174,
+            601,
+            825,
+            642
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Future work can improve the current method by training larger models over much larger corpora including other domains and languages. While the current model seems to focus primarily on syntax, extra unsupervised objectives or light supervision could be injected into the learning procedure to encourage a more thorough capturing of semantics. ",
+        "bbox": [
+            174,
+            650,
+            825,
+            705
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "REFERENCES ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            729,
+            285,
+            744
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Patrick Verga, David Belanger, Emma Strubell, Benjamin Roth, and Andrew McCallum. Multilingual relation extraction using compositional universal schema. In Proceedings of the 2016 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, pages 886–896, San Diego, California, June 2016. Association for Computational Linguistics. URL http://www.aclweb.org/anthology/N16-1103. ",
+        "bbox": [
+            174,
+            755,
+            825,
+            825
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Emma Strubell, Patrick Verga, Daniel Andor, David Weiss, and Andrew McCallum. LinguisticallyInformed Self-Attention for Semantic Role Labeling. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018. ",
+        "bbox": [
+            174,
+            838,
+            821,
+            881
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Roee Aharoni and Yoav Goldberg. Towards string-to-tree neural machine translation. In Proceedings of the 55th Annual Meeting of the Association for Computational Linguistics, 2017. ",
+        "bbox": [
+            173,
+            895,
+            823,
+            924
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "Kai Sheng Tai, Richard Socher, and Christopher D. Manning. Improved semantic representations from tree-structured long short-term memory networks. In ACL, 2015. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mitchell Marcus, Grace Kim, Mary Ann Marcinkiewicz, Robert MacIntyre, Ann Bies, Mark Ferguson, Karen Katz, and Britta Schasberger. The penn treebank: annotating predicate argument structure. In Proceedings of the workshop on Human Language Technology, pages 114–119. Association for Computational Linguistics, 1994. ",
+        "bbox": [
+            173,
+            140,
+            825,
+            195
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phong Le and Willem Zuidema. The forest convolutional network: Compositional distributional semantics with a neural chart and without binarization. In Proceedings of the 2015 Conference on Empirical Methods in Natural Language Processing, pages 1155–1164, 2015. ",
+        "bbox": [
+            176,
+            204,
+            823,
+            247
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dani Yogatama, Phil Blunsom, Chris Dyer, Edward Grefenstette, and Wang Ling. Learning to compose words into sentences with reinforcement learning. arXiv preprint arXiv:1611.09100, 2016. ",
+        "bbox": [
+            176,
+            253,
+            821,
+            296
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jean Maillard, Stephen Clark, and Dani Yogatama. Jointly learning sentence embeddings and syntax with unsupervised tree-lstms. arXiv preprint arXiv:1705.09189, 2017. ",
+        "bbox": [
+            171,
+            304,
+            823,
+            334
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Jihun Choi, Kang Min Yoo, and Sang-goo Lee. Learning to compose task-specific tree structures. In In Proceedings of the Thirty-Second AAAI Conference on Artificial Intelligence, New Orleans, Louisiana, USA, February 2-7, 2018, 2018. ",
+        "bbox": [
+            174,
+            340,
+            823,
+            383
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Andrew Drozdov, and Samuel R Bowman. Do latent tree learning models identify meaningful structure in sentences? Transactions of the Association of Computational Linguistics, 6:253–267, 2018a. ",
+        "bbox": [
+            173,
+            391,
+            823,
+            434
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "James K Baker. Trainable grammars for speech recognition. The Journal of the Acoustical Society of America, 65(S1):S132–S132, 1979. ",
+        "bbox": [
+            171,
+            441,
+            823,
+            470
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Karim Lari and Steve J Young. The estimation of stochastic context-free grammars using the insideoutside algorithm. Computer speech & language, 4(1):35–56, 1990. ",
+        "bbox": [
+            171,
+            478,
+            823,
+            508
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Yikang Shen, Zhouhan Lin, Chin-Wei Huang, and Aaron Courville. Neural language modeling by jointly learning syntax and lexicon. 2018. ",
+        "bbox": [
+            173,
+            515,
+            823,
+            544
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Phu Mon Htut, Kyunghyun Cho, and Samuel R Bowman. Grammar induction with neural language models: An unusual replication. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018. ",
+        "bbox": [
+            176,
+            551,
+            823,
+            594
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Tadao Kasami. An efficient recognition and syntax-analysis algorithm for context-free languages. Coordinated Science Laboratory Report no. R-257, 1966. ",
+        "bbox": [
+            169,
+            602,
+            821,
+            631
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Daniel H Younger. Recognition and parsing of context-free languages in time n3. Information and control, 10(2):189–208, 1967. ",
+        "bbox": [
+            174,
+            638,
+            823,
+            667
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Pytorch Core Team. Pytorch: Tensors and dynamic neural networks in python with strong gpu acceleration. http://pytorch.org/, 2018. Accessed: 2018-09-26. ",
+        "bbox": [
+            171,
+            674,
+            821,
+            704
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Adina Williams, Nikita Nangia, and Samuel Bowman. A broad-coverage challenge corpus for sentence understanding through inference. In Proceedings of the 2018 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies, Volume 1 (Long Papers), pages 1112–1122. Association for Computational Linguistics, 2018b. URL http://aclweb.org/anthology/N18-1101. ",
+        "bbox": [
+            174,
+            712,
+            825,
+            782
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Christopher Manning, Mihai Surdeanu, John Bauer, Jenny Finkel, Steven Bethard, and David McClosky. The stanford corenlp natural language processing toolkit. In Proceedings of 52nd annual meeting of the association for computational linguistics: system demonstrations, pages 55–60, 2014. ",
+        "bbox": [
+            174,
+            790,
+            825,
+            844
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Ari Kobren, Nicholas Monath, Akshay Krishnamurthy, and Andrew McCallum. A hierarchical algorithm for extreme clustering. In Proceedings of the 23rd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD ’17, pages 255–264, New York, NY, USA, 2017. ACM. ISBN 978-1-4503-4887-4. doi: 10.1145/3097983.3098079. URL http://doi.acm.org/10.1145/3097983.3098079. ",
+        "bbox": [
+            176,
+            854,
+            825,
+            924
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthew E. Peters, Mark Neumann, Mohit Iyyer, Matt Gardner, Christopher Clark, Kenton Lee, and Luke Zettlemoyer. Deep contextualized word representations. In Proc. of NAACL, 2018a. ",
+        "bbox": [
+            171,
+            103,
+            823,
+            132
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Matthew E Peters, Mark Neumann, Luke Zettlemoyer, and Wen-tau Yih. Dissecting contextual word embeddings: Architecture and representation. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018b. ",
+        "bbox": [
+            174,
+            140,
+            823,
+            184
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Yang Liue, Matt Gardner, and Mirella Lapata. Structured alignment networks. In Conference on Empirical Methods in Natural Language Processing (EMNLP), Brussels, Belgium, October 2018. ",
+        "bbox": [
+            173,
+            193,
+            823,
+            222
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Phong Le and Willem Zuidema. The inside-outside recursive neural network model for dependency parsing. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 729–739, 2014. ",
+        "bbox": [
+            176,
+            229,
+            823,
+            272
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Greg Durrett and Dan Klein. Neural crf parsing. In ACL, 2015. ",
+        "bbox": [
+            173,
+            281,
+            589,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elias Ponvert, Jason Baldridge, and Katrin Erk. Simple unsupervised grammar induction from raw text with cascaded finite state models. In ACL, 2011. ",
+        "bbox": [
+            174,
+            306,
+            823,
+            334
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Elias Ponvert, Jason Baldridge, and Katrin Erk. Simple unsupervised identification of low-level constituents. 2010 IEEE Fourth International Conference on Semantic Computing, pages 24–31, 2010. ",
+        "bbox": [
+            174,
+            343,
+            825,
+            386
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Klein and Christopher D. Manning. A generative constituent-context model for improved grammar induction. In ACL, 2002. ",
+        "bbox": [
+            174,
+            395,
+            821,
+            424
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dan Klein and Christopher D. Manning. Corpus-based induction of syntactic structure: Models of dependency and constituency. In ACL, 2004. ",
+        "bbox": [
+            174,
+            433,
+            821,
+            462
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Dipanjan Das and Slav Petrov. Unsupervised part-of-speech tagging with bilingual graph-based projections. In ACL, 2011. ",
+        "bbox": [
+            174,
+            470,
+            823,
+            500
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Shay B. Cohen, Dipanjan Das, and Noah A. Smith. Unsupervised structure prediction with nonparallel multilingual guidance. In EMNLP, 2011. ",
+        "bbox": [
+            173,
+            508,
+            821,
+            537
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Jeffrey Pennington, Richard Socher, and Christopher Manning. Glove: Global vectors for word representation. In Proceedings of the 2014 conference on empirical methods in natural language processing (EMNLP), pages 1532–1543, 2014. ",
+        "bbox": [
+            173,
+            546,
+            825,
+            589
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "A APPENDIX ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            102,
+            297,
+            117
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "A.1 TRAINING DETAILS ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            133,
+            354,
+            147
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "All DIORA experiments are trained with these settings unless otherwise specified: we use the ALLNLI corpus including only sentences with length less than 20, stochastic gradient descent with a batch size of 256, and the model dimension set to 200. The input sentences are embedded using the 300D 480B GloVe embeddings (Pennington et al., 2014) and are not updated during training. Sentences are grouped into batches with uniform sentence length. Each cell in the chart has its L2- norm set to 1. Early stopping is done using the reconstruction objective evaluated on a held-out set. When depending on Noise Contrastive Estimation (as is the case in the reconstruction objective), we sample 3 negative examples per positive example. ",
+        "bbox": [
+            174,
+            160,
+            825,
+            271
+        ],
+        "page_idx": 11
+    }
+]

parse/train/SJzMATlAZ/SJzMATlAZ.md

@@ -0,0 +1,331 @@
+# DEEP CONTINUOUS CLUSTERING
+
+Anonymous authors Paper under double-blind review
+
+# ABSTRACT
+
+Clustering high-dimensional datasets is hard because interpoint distances become less informative in high-dimensional spaces. We present a clustering algorithm that performs nonlinear dimensionality reduction and clustering jointly. The data is embedded into a lower-dimensional space by a deep autoencoder. The autoencoder is optimized as part of the clustering process. The resulting network produces clustered data. The presented approach does not rely on prior knowledge of the number of ground-truth clusters. Joint nonlinear dimensionality reduction and clustering are formulated as optimization of a global continuous objective. We thus avoid discrete reconfigurations of the objective that characterize prior clustering algorithms. Experiments on datasets from multiple domains demonstrate that the presented algorithm outperforms state-of-the-art clustering schemes, including recent methods that use deep networks.
+
+# 1 INTRODUCTION
+
+Clustering is a fundamental procedure in machine learning and data analysis. Well-known approaches include center-based methods and their generalizations (Banerjee et al., 2005; Teboulle, 2007), and spectral methods $\mathrm { N g }$ et al., 2001; von Luxburg, 2007). Despite decades of progress, reliable clustering of noisy high-dimensional datasets remains an open problem. High dimensionality poses a particular challenge because assumptions made by many algorithms break down in high-dimensional spaces (Ball, 1997; Beyer et al., 1999; Steinbach et al., 2004).
+
+There are techniques that reduce the dimensionality of data by embedding it in a lower-dimensional space (van der Maaten et al., 2009). Such general techniques, based on preserving variance or dissimilarity, may not be optimal when the goal is to discover cluster structure. Dedicated algorithms have been developed that combine dimensionality reduction and clustering by fitting low-dimensional subspaces (Kriegel et al., 2009; Vidal, 2011). Such algorithms can achieve better results than pipelines that first apply generic dimensionality reduction and then cluster in the reduced space. However, frameworks such as subspace clustering and projected clustering operate on linear subspaces and are therefore limited in their ability to handle datasets that lie on nonlinear manifolds.
+
+Recent approaches have sought to overcome this limitation by constructing a nonlinear embedding of the data into a low-dimensional space in which it is clustered (Dizaji et al., 2017; Xie et al., 2016; Yang et al., 2016; 2017). Ultimately, the goal is to perform nonlinear embedding and clustering jointly, such that the embedding is optimized to bring out the latent cluster structure. These works have achieved impressive results. Nevertheless, they are based on classic center-based, divergencebased, or hierarchical clustering formulations and thus inherit some limitations from these classic methods. In particular, these algorithms require setting the number of clusters a priori. And the optimization procedures they employ involve discrete reconfigurations of the objective, such as discrete reassignments of datapoints to centroids or merging of putative clusters in an agglomerative procedure. Thus it is challenging to integrate them with an optimization procedure that modifies the embedding of the data itself.
+
+We seek a procedure for joint nonlinear embedding and clustering that overcomes some of the limitations of prior formulations. There are a number of characteristics we consider desirable. First, we wish to express the joint problem as optimization of a single continuous objective. Second, this optimization should be amenable to scalable gradient-based solvers such as modern variants of SGD. Third, the formulation should not require setting the number of clusters a priori, since this number is often not known in advance.
+
+While any one of these desiderata can be fulfilled by some existing approaches, the combination is challenging. For example, it has long been known that the $k$ -means objective can be optimized by SGD (Bottou & Bengio, 1994). But this family of formulations requires positing the number of clusters $k$ in advance. Furthermore, the optimization is punctuated by discrete reassignments of datapoints to centroids, and is thus hard to integrate with continuous embedding of the data.
+
+In this paper, we present a formulation for joint nonlinear embedding and clustering that possesses all of the aforementioned desirable characteristics. Our approach is rooted in Robust Continuous Clustering (RCC), a recent formulation of clustering as continuous optimization of a robust objective (Shah & Koltun, 2017). The basic RCC formulation has the characteristics we seek, such as a clear continuous objective and no prior knowledge of the number of clusters. However, integrating it with deep nonlinear embedding is still a challenge. For example, Shah & Koltun (2017) presented a formulation for joint linear embedding and clustering (RCC-DR), but this formulation relies on a complex alternating optimization scheme with linear least-squares subproblems, and does not apply to nonlinear embeddings.
+
+We present an integration of the RCC objective with dimensionality reduction that is simpler and more direct than RCC-DR, while naturally handling deep nonlinear embeddings. Our formulation avoids alternating optimization and the introduction of auxiliary dual variables. A deep nonlinear embedding of the data into a low-dimensional space is optimized while the data is clustered in the reduced space. The optimization is expressed by a global continuous objective and conducted by standard gradient-based solvers.
+
+The presented algorithm is evaluated on high-dimensional datasets of images and documents. Experiments demonstrate that our formulation performs on par or better than state-of-the-art clustering algorithms across all datasets. This includes recent approaches that utilize deep networks and rely on prior knowledge of the number of ground-truth clusters. Controlled experiments confirm that joint dimensionality reduction and clustering is more effective than a stagewise approach, and that the high accuracy achieved by the presented algorithm is stable across different dimensionalities of the latent space.
+
+# 2 PRELIMINARIES
+
+Let $\mathbf { X } = [ \mathbf { x } _ { 1 } , \dots , \mathbf { x } _ { N } ]$ be a set of points in $\mathbb { R } ^ { D }$ that must be clustered. Generic clustering algorithms that operate directly on $\mathbf { X }$ rely strongly on interpoint distances. When $D$ is high, these distances become less informative (Ball, 1997; Beyer et al., 1999). Hence most clustering algorithms do not operate effectively in high-dimensional spaces. To overcome this problem, we embed the data into a lower-dimensional space $\mathbb { R } ^ { d }$ . The embedding of the dataset into $\mathbb { R } ^ { \bar { d } }$ is denoted by $\mathbf { Y } = [ \mathbf { y } _ { 1 } , \dots , \mathbf { y } _ { N } ]$ The function that performs the embedding is denoted by $f _ { \pmb { \theta } } : \mathbb { R } ^ { D }  \mathbb { R } ^ { d }$ . Thus $\mathbf { y } _ { i } = f _ { \pmb { \theta } } ( \mathbf { x } _ { i } )$ for all $i$
+
+Our goal is to cluster the embedded dataset $\mathbf { Y }$ and to optimize the parameters $\pmb \theta$ of the embedding as part of the clustering process. This formulation presents an obvious difficulty: if the embedding $f _ { \theta }$ can be manipulated to assist the clustering of the embedded dataset $\mathbf { Y }$ , there is nothing that prevents $f _ { \theta }$ from distorting the dataset such that $\mathbf { Y }$ no longer respects the structure of the original data. We must therefore introduce a regularizer on $\pmb \theta$ that constrains the low-dimensional image $\mathbf { Y }$ with respect to the original high-dimensional dataset $\mathbf { X }$ . To this end, we also consider a reverse mapping $g _ { \omega } : \mathbb { R } ^ { d }  \mathbb { R } ^ { D }$ . To constrain $f _ { \theta }$ to construct a faithful embedding of the original data, we require that the original data be reproducible from its low-dimensional image (Hinton $\&$ Salakhutdinov, 2006):
+
+$$
+\operatorname* { m i n i m i z e } \ \| \mathbf { X } - G _ { \omega } ( \mathbf { Y } ) \| _ { F } ^ { 2 } , \qquad \mathrm { w h e r e ~ } \mathbf { Y } = F _ { \theta } ( \mathbf { X } ) , \quad \Omega = \{ \theta , \omega \} .
+$$
+
+Here $F _ { \pmb \theta } ( \mathbf { X } ) = [ f _ { \pmb \theta } ( \mathbf { x } _ { 1 } ) , \dots , f _ { \pmb \theta } ( \mathbf { x } _ { N } ) ]$ , $G _ { \omega } ( { \mathbf Y } ) = [ g _ { \omega } ( { \mathbf y } _ { 1 } ) , \dots , g _ { \omega } ( { \mathbf y } _ { N } ) ]$ , and $\Vert \cdot \Vert _ { F }$ denotes the Frobenius norm.
+
+Next, we must decide how the low-dimensional embedding $\mathbf { Y }$ will be clustered. A natural solution is to choose a classic clustering framework: a center-based method such as $k$ -means, a divergence-based formulation, or an agglomerative approach. These are the paths taken in recent work on combining nonlinear dimensionality reduction and clustering (Dizaji et al., 2017; Xie et al., 2016; Yang et al., 2016; 2017). However, the classic clustering algorithms have a discrete structure: associations between centroids and datapoints need to be recomputed or putative clusters need to be merged. In either case, the optimization process is punctuated by discrete reconfigurations. This makes it difficult to coordinate the clustering of $\mathbf { Y }$ with the optimization of the embedding parameters $\pmb { \Omega }$ that modify the dataset $\mathbf { Y }$ itself.
+
+Since we must conduct clustering in tandem with continuous optimization of the embedding, we seek a clustering algorithm that is inherently continuous and performs clustering by optimizing a continuous objective that does not need to be updated during the optimization. The recent RCC formulation provides a suitable starting point (Shah & Koltun, 2017). The key idea of RCC is to introduce a set of representatives $\mathbf { Z } \in \mathbb { R } ^ { d \times N }$ and optimize the following nonconvex objective:
+
+$$
+\operatorname* { m i n i m i z e } _ { \mathbf { z } } \ \frac { 1 } { 2 } \| \mathbf { Z } - \mathbf { Y } \| _ { F } ^ { 2 } + \frac { \lambda } { 2 } \sum _ { ( i , j ) \in \mathcal { E } } w _ { i , j } \rho ( \| \mathbf { z } _ { i } - \mathbf { z } _ { j } \| _ { 2 } ) ,
+$$
+
+where $\rho$ is a redescending M-estimator, $\mathcal { E }$ is a graph connecting the datapoints, $\{ w _ { i , j } \}$ are appropriately defined weights, and $\lambda$ is a coefficient that balances the two objective terms. The first term in objective (2) constrains the representatives to remain near the corresponding datapoints. The second term pulls the representatives to each other, encouraging them to merge. This formulation has a number of advantages. First, it reduces clustering to optimization of a fixed continuous objective. Second, each datapoint has its own representative in $\mathbf { Z }$ and no prior knowledge of the number of clusters is needed. Third, the nonconvex robust estimator $\rho$ limits the influence of outliers.
+
+To perform nonlinear embedding and clustering jointly, we wish to integrate the reconstruction objective (1) and the RCC objective (2). This idea is developed in the next section.
+
+# 3 DEEP CONTINUOUS CLUSTERING
+
+# 3.1 OBJECTIVE
+
+The Deep Continuous Clustering (DCC) algorithm optimizes the following objective:
+
+$$
+\mathcal { L } ( \Omega , \mathbf { Z } ) = \frac { 1 } { D } \underbrace { \| \mathbf { X } - G _ { \omega } ( \mathbf { Y } ) \| _ { F } ^ { 2 } } _ { \mathrm { r e c o n s i r u c t i o n \ l o s s } } + \frac { 1 } { d } \left( \sum _ { i } \rho _ { 1 } \big ( \| \mathbf { z } _ { i } - \mathbf { y } _ { i } \| _ { 2 } ; \mu _ { 1 } \big ) + \lambda \sum _ { ( i , j ) \in \mathcal { E } } w _ { i , j } \rho _ { 2 } \big ( \| \mathbf { z } _ { i } - \mathbf { z } _ { j } \| _ { 2 } ; \mu _ { 2 } \big ) \right)
+$$
+
+where $\mathbf { Y } = F _ { \pmb { \theta } } ( \mathbf { X } )$
+
+This formulation bears some similarity to RCC-DR (Shah & Koltun, 2017), but differs in three major respects. First, RCC-DR only operates on a linear embedding defined by a sparse dictionary, while DCC optimizes a more expressive nonlinear embedding parameterized by $\pmb { \Omega }$ . Second, RCC-DR alternates between optimizing dictionary atoms, sparse codes, representatives $\mathbf { Z }$ , and dual line process variables; in contrast, DCC avoids duality altogether and optimizes the global objective directly. Third, DCC does not rely on closed-form or linear least-squares solutions to subproblems; rather, the joint objective is optimized by modern gradient-based solvers, which are commonly used for deep representation learning and are highly scalable.
+
+We now discuss objective (3) and its optimization in more detail. The mappings $F _ { \theta }$ and $G _ { \omega }$ are performed by an autoencoder with fully-connected or convolutional layers and rectified linear units after each affine projection (Hinton & Salakhutdinov, 2006; Nair & Hinton, 2010). The graph $\mathcal { E }$ is constructed on $\mathbf { X }$ using the mutual kNN criterion (Brito et al., 1997), augmented by the minimum spanning tree of the kNN graph to ensure connectivity to all datapoints. The role of M-estimators $\rho _ { 1 }$ and $\rho _ { 2 }$ is to pull the representatives of a true underlying cluster into a single point, while disregarding spurious connections across clusters. For both estimators, we use scaled Geman-McClure functions (Geman & McClure, 1987):
+
+$$
+\rho _ { 1 } ( x ; \mu _ { 1 } ) = { \frac { \mu _ { 1 } x ^ { 2 } } { \mu _ { 1 } + x ^ { 2 } } } \quad { \mathrm { a n d } } \quad \rho _ { 2 } ( x ; \mu _ { 2 } ) = { \frac { \mu _ { 2 } x ^ { 2 } } { \mu _ { 2 } + x ^ { 2 } } } .
+$$
+
+The parameters $\mu _ { 1 }$ and $\mu _ { 2 }$ control the radii of the convex basins of the estimators. The weights $w _ { i , j }$ are set to balance the contribution of each datapoint to the pairwise loss:
+
+$$
+w _ { i , j } = { \frac { { \frac { 1 } { N } } \sum _ { k = 1 } ^ { n } n _ { k } } { \sqrt { n _ { i } n _ { j } } } } .
+$$
+
+Here $n _ { i }$ is the degree of $\mathbf { z } _ { i }$ in the graph $\mathcal { E }$ . The numerator is simply the average degree. The parameter $\lambda$ balances the relative strength of the data loss and the pairwise loss. To balance the different terms, we set $\begin{array} { r } { \lambda = \frac { \| \mathbf { Y } \| _ { 2 } } { \| \mathbf { A } \| _ { 2 } } } \end{array}$ , where $\begin{array} { r } { \mathbf { A } = \sum _ { ( i , j ) \in \mathcal { E } } w _ { i , j } ( \mathbf { e } _ { i } - \mathbf { e } _ { j } ) ( \mathbf { e } _ { i } - \mathbf { e } _ { j } ) ^ { \top } } \end{array}$ and $\| \cdot \| _ { 2 }$ denotes the spectral norm. In contrast to RCC-DR, the parameter $\lambda$ need not be updated during the optimization.
+
+# 3.2 OPTIMIZATION
+
+Objective (3) can be optimized using scalable modern forms of stochastic gradient descent (SGD). Note that each $\mathbf { z } _ { i }$ is updated only via its corresponding loss and pairwise terms. On the other hand, the autoencoder parameters $\pmb { \Omega }$ are updated via all data samples. Thus in a single epoch, there is bound to be a difference between the update rates for $\mathbf { Z }$ and $\pmb { \Omega }$ . To deal with this imbalance, an adaptive solver such as Adam should be used (Kingma & Ba, 2015).
+
+Another difficulty is that the graph $\mathcal { E }$ connects all datapoints such that a randomly sampled minibatch is likely to be connected by pairwise terms to datapoints outside the minibatch. In other words, the objective (3), and more specifically the pairwise loss, does not trivially decompose over datapoints. This requires some care in the construction of minibatches. Instead of sampling datapoints, we sample subsets of edges from $\mathcal { E }$ . The corresponding minibatch $\boldsymbol { B }$ is defined by all nodes incident to the sampled edges. However, if we simply restrict the objective (3) to the minibatch and take a gradient step, the reconstruction and data terms will be given additional weight since the same datapoint can participate in different minibatches, once for each incident edge. To maintain balance between the terms, we must weigh the contribution of each datapoint in the minibatch. The rebalanced minibatch loss is given by
+
+$$
+\hat { \mathbf { \xi } } _ { B } ( \mathbf { \Omega } , \mathbf { Z } ) = \frac { 1 } { | B | } \sum _ { i \in B } w _ { i } \left( \frac { \| \mathbf { x } _ { i } - g _ { \omega } ( \mathbf { y } _ { i } ) \| _ { 2 } ^ { 2 } } { D } + \frac { \rho _ { 1 } \left( \left\| \mathbf { z } _ { i } - \mathbf { y } _ { i } \right\| _ { 2 } \right) } { d } \right) + \frac { \lambda } { | B | } \sum _ { ( i , j ) \in \mathcal { E } _ { B } } w _ { i , j } \rho _ { 2 } \left( \left\| \mathbf { z } _ { i } - \mathbf { z } _ { j } \right\| _ { 2 } \right)
+$$
+
+where $\mathbf { y } _ { i } = f _ { \pmb { \theta } } ( \mathbf { x } _ { i } ) \quad \forall i \in \pmb { B }$ .
+
+Here $\begin{array} { r } { w _ { i } = \frac { n _ { i } ^ { \mathtt { B } } } { n _ { i } } } \end{array}$ , where $n _ { i } ^ { B }$ is the number of edges connected to the $i ^ { \mathrm { t h } }$ node in the subgraph $\mathcal { E } _ { B }$
+
+The gradients of $\mathcal { L } _ { B }$ with respect to the low-dimensional embedding $\mathbf { Y }$ and the representatives $\mathbf { Z }$ are given by
+
+$$
+\begin{array} { r l } & { \displaystyle \frac { \partial \mathcal { L } _ { \mathcal { B } } } { \partial \mathbf { y } _ { i } } = \frac { 1 } { | \mathcal { B } | } \left( \frac { w _ { i } \mu _ { 1 } ^ { 2 } ( \mathbf { y } _ { i } - \mathbf { z } _ { i } ) } { d ( \mu _ { 1 } + \| \mathbf { z } _ { i } - \mathbf { y } _ { i } \| _ { 2 } ^ { 2 } ) ^ { 2 } } + \frac { 2 w _ { i } ( g _ { \omega } ( \mathbf { y } _ { i } ) - \mathbf { x } _ { i } ) } { D } \frac { \partial g _ { \omega } ( \mathbf { y } _ { i } ) } { \partial \mathbf { y } _ { i } } \right) } \\ & { \displaystyle \frac { \partial \mathcal { L } _ { \mathcal { B } } } { \partial \mathbf { z } _ { i } } = \frac { 1 } { | \mathcal { B } | } \left( \frac { w _ { i } \mu _ { 1 } ^ { 2 } ( \mathbf { z } _ { i } - \mathbf { y } _ { i } ) } { d ( \mu _ { 1 } + \| \mathbf { z } _ { i } - \mathbf { y } _ { i } \| _ { 2 } ^ { 2 } ) ^ { 2 } } + { \lambda } \mu _ { 2 } ^ { 2 } \sum _ { ( i , j ) \in \mathcal { E } _ { \mathcal { B } } } \frac { w _ { i , j } ( \mathbf { z } _ { i } - \mathbf { z } _ { j } ) } { ( \mu _ { 2 } + \| \mathbf { z } _ { i } - \mathbf { z } _ { j } \| _ { 2 } ^ { 2 } ) ^ { 2 } } \right) } \end{array}
+$$
+
+These gradients are propagated to the parameters $\pmb { \Omega }$ .
+
+# 3.3 INITIALIZATION, CONTINUATION AND STOPPING CRITERION
+
+Initialization. The embedding parameters $\pmb { \Omega }$ are initialized using the stacked denoising autoencoder (SDAE) framework (Vincent et al., 2010). Each pair of corresponding encoding and decoding layers is pretrained in turn. Noise is introduced during pretraining by adding dropout to the input of each affine projection (Srivastava et al., 2014). Encoder-decoder layer pairs are pretrained sequentially, from the outer to the inner. After all layer pairs are pretrained, the entire SDAE is fine-tuned end-to-end using the reconstruction loss. This completes the initialization of the embedding parameters $\pmb { \Omega }$ . These parameters are used to initialize the representatives $\mathbf { Z }$ , which are set to $\mathbf { Z } = \mathbf { Y } = F _ { \pmb { \theta } } ( \mathbf { X } )$ .
+
+Continuation. The price of robustness is the nonconvexity of the estimators $\rho _ { 1 }$ and $\rho _ { 2 }$ . One way to alleviate the dangers of nonconvexity is to use a continuation scheme that gradually sharpens the estimator (Blake & Zisserman, 1987; Mobahi & Fisher III, 2015). Following Shah & Koltun (2017), we initially set $\mu _ { i }$ to a high value that makes the estimator $\rho _ { i }$ effectively convex in the relevant range. The value of $\mu _ { i }$ is decreased on a regular schedule until a threshold $\frac { \delta _ { i } } { 2 }$ is reached. We set $\delta _ { 1 }$ to the mean of the distance of each $\mathbf { y } _ { i }$ to the mean of $\mathbf { Y }$ , and $\delta _ { 2 }$ to the mean of the bottom $1 \%$ of the pairwise distances in $\mathcal { E }$ at initialization.
+
+# Algorithm 1 Deep Continuous Clustering
+
+1: input: Data samples $\{ { \bf { x } } _ { i } \} _ { i }$ .   
+2: output: Cluster assignment $\{ c _ { i } \} _ { i }$ .   
+3: Construct a graph $\mathcal { E }$ on $\mathbf { X }$ .   
+4: Initialize $\pmb { \Omega }$ and $\mathbf { Z }$ .   
+5: Precompute $\lambda , w _ { i , j } , \delta _ { 1 } , \delta _ { 2 }$ . Initialize $\mu _ { 1 } , \mu _ { 2 }$ .   
+6: while stopping criterion not met do   
+7: Every iteration, construct a minibatch $\boldsymbol { B }$ defined by a sample of edges $\mathcal { E } _ { B }$ .   
+8: Update $\{ \mathbf { z } _ { i } \} _ { i \in B }$ and $\pmb { \Omega }$ .   
+9: Every $M$ epochs, update $\begin{array} { r } { \mu _ { i } = \operatorname* { m a x } \left( \frac { \mu _ { i } } { 2 } , \frac { \delta _ { i } } { 2 } \right) } \end{array}$ .   
+10: end while   
+11: Construct graph $\mathcal { G } = ( \nu , \mathcal { F } )$ with $f _ { i , j } = 1$ if $\| \mathbf { z } _ { i } ^ { * } - \mathbf { z } _ { j } ^ { * } \| _ { 2 } < \delta _ { 2 }$ .   
+12: Output clusters given by the connected components of $\mathcal { G }$ .
+
+Stopping criterion. Once the continuation scheme is completed, DCC monitors the computed clustering. At the end of every epoch, a graph $\mathcal { G } = ( \nu , \mathcal { F } )$ is constructed such that $f _ { i , j } = 1$ if $\| \mathbf { z } _ { i } - \mathbf { z } _ { j } \| < \delta _ { 2 }$ . The cluster assignment is given by the connected components of $\mathcal { G }$ . DCC compares this cluster assignment to the one produced at the end of the preceding epoch. If less than $0 . 1 \%$ of the edges in $\mathcal { E }$ changed from intercluster to intracluster or vice versa, DCC outputs the computed clustering and terminates.
+
+Complete algorithm. The complete algorithm is summarized in Algorithm 1.
+
+# 4 EXPERIMENTS
+
+# 4.1 DATASETS
+
+We conduct experiments on six high-dimensional datasets, which cover domains such as handwritten digits, objects, faces, and text. We used datasets from Shah & Koltun (2017) that had dimensionality above 100. The datasets are further described in the appendix. All features are normalized to the range [0, 1].
+
+Note that DCC is an unsupervised learning algorithm. Unlabelled data is embedded and clustered with no supervision. There is thus no train/test split.
+
+# 4.2 BASELINES
+
+The presented DCC algorithm is compared to 12 baselines, which include both classic and deep clustering algorithms. The baselines include $k$ -means $^ { + + }$ (Arthur & Vassilvitskii, 2007), DBSCAN (Ester et al., 1996), two variants of agglomerative clustering: Ward (AC-W) and graph degree linkage (GDL) (Zhang et al., 2012), two variants of spectral clustering: spectral embedded clustering (SEC) (Nie et al., 2011) and local discriminant models and global integration (LDMGI) (Yang et al., 2010), and two variant of robust continuous clustering: RCC and RCC-DR (Shah & Koltun, 2017).
+
+The deep clustering baselines include four recent approaches that share our basic motivation and use deep networks for clustering: deep embedded clustering (DEC) (Xie et al., 2016), joint unsupervised learning (JULE) (Yang et al., 2016), the deep clustering network (DCN) (Yang et al., 2017), and deep embedded regularized clustering (DEPICT) (Dizaji et al., 2017). These are strong baselines that use deep autoencoders, the same network structure as our approach (DCC). The key difference is in the loss function and the consequent optimization procedure. The prior formulations are built on KLdivergence clustering, agglomerative clustering, and $k$ -means, which involve discrete reconfiguration of the objective during the optimization and rely on knowledge of the number of ground-truth clusters either in the design of network architecture, during the embedding optimization, or in post-processing. In contrast, DCC optimizes a robust continuous loss and does not rely on prior knowledge of the number of clusters.
+
+# 4.3 IMPLEMENTATION
+
+We report experimental results for two different autoencoder architectures: one with only fullyconnected layers and one with convolutional layers. This is motivated by prior deep clustering algorithms, some of which used fully-connected architectures and some convolutional.
+
+For fully-connected autoencoders, we use the same autoencoder architecture as DEC (Xie et al., 2016). Specifically, for all experiments on all datasets, we use an autoencoder with the following dimensions: D–500–500–2000–d–2000–500–500–D. This autoencoder architecture follows parametric t-SNE (van der Maaten, 2009).
+
+For convolutional autoencoders, the network architecture is modeled on JULE (Yang et al., 2016). The architecture is specified in the appendix. As in Yang et al. (2016), the number of layers depends on image resolution in the dataset and it is set such that the output resolution of the encoder is about $4 \times 4$ .
+
+In both architectures and for all datasets, the dimensionality of the reduced space is set to $d = 1 0$ . (It is only varied for controlled experiments that analyze stability with respect to $d$ .) No dataset-specific hyperparameter tuning was done. For autoencoder initialization, a minibatch size of 256 and dropout probability of 0.2 are used. SDAE pretraining and finetuning start with a learning rate of 0.1, which is decreased by a factor of 10 every 80 epochs. Each layer is pretrained for 200 epochs. Finetuning of the whole SDAE is performed for 400 epochs. For the fully-connected SDAE, the learning rates are scaled in accordance with the dimensionality of the dataset.
+
+For m-kNN graph construction, the nearest-neighbor parameter $k$ is set to 10 and the cosine distance metric is used. The Adam solver is used with its default learning rate of 0.001 and momentum 0.99. Minibatches are constructed by sampling 128 edges. DCC was implemented using the PyTorch library.
+
+For the baselines, we use publicly available implementations. For $k$ -means $^ { + + }$ , DBSCAN and ACW, we use the implementations in the SciPy library and report the best results across ten random restarts. For a number of baselines, we performed hyperparameter search to maximize their reported performance. For DBSCAN, we searched over values of $E p s$ , for LDMGI we searched over values of the regularization constant $\lambda$ , for SEC we searched over values of the parameter $\mu$ , and for GDL we tuned the graph construction parameter $a$ .
+
+The DCN approach uses a different network architecture for each dataset. Wherever possible, we report results using their dataset-specific architecture. For YTF, Coil100, and YaleB, we use their reference architecture for MNIST.
+
+# 4.4 MEASURES
+
+Common measures of clustering accuracy include normalized mutual information (NMI) (Strehl & Ghosh, 2002) and clustering accuracy (ACC). However, NMI is known to be biased in favor of fine-grained partitions and ACC is also biased on imbalanced datasets (Vinh et al., 2010). To overcome these biases, we use adjusted mutual information (AMI) (Vinh et al., 2010), defined as
+
+$$
+\mathrm { A M I } ( \mathbf { c } , \hat { \mathbf { c } } ) = \frac { \mathbf { M } \mathrm { I } ( \mathbf { c } , \hat { \mathbf { c } } ) - E [ \mathbf { M } \mathrm { I } ( \mathbf { c } , \hat { \mathbf { c } } ) ] } { \sqrt { \mathbf { H } ( \mathbf { c } ) \mathbf { H } ( \hat { \mathbf { c } } ) } - E [ \mathbf { M } \mathrm { I } ( \mathbf { c } , \hat { \mathbf { c } } ) ] } .
+$$
+
+Here $\mathrm { H } ( \cdot )$ is the entropy, $\operatorname { M I } ( \cdot , \cdot )$ is the mutual information, and c and cˆ are the two partitions being compared. AMI lies in a range $[ 0 , 1 ]$ . Higher is better. For completeness, results according to ACC are reported in the appendix.
+
+# 4.5 RESULTS
+
+The results are summarized in Table 1. Among deep clustering methods that use fully-connected networks, DCN and DEC are not as accurate as fully-connected DCC and are also less consistent: the performance of DEC drops on the high-dimensional image datasets, while DCN is far behind on MNIST and YaleB. Among deep clustering methods that use convolutional networks, the performance of DEPICT drops on COIL100 and YTF, while JULE is far behind on YTF. The GDL algorithm failed to scale to the full MNIST dataset and the corresponding measurement is marked as $\mathrm { \dot { \Omega } n / a \Omega ^ { \prime } }$ .
+
+<table><tr><td>Algorithm</td><td>MNIST</td><td>Coil100</td><td>YTF</td><td>YaleB</td><td>Reuters</td><td>RCV1</td></tr><tr><td>k-means++</td><td>0.500</td><td>0.803</td><td>0.783</td><td>0.615</td><td>0.516</td><td>0.355</td></tr><tr><td>AC-W</td><td>0.679</td><td>0.853</td><td>0.801</td><td>0.767</td><td>0.471</td><td>0.364</td></tr><tr><td>DBSCAN</td><td>0.000</td><td>0.399</td><td>0.739</td><td>0.456</td><td>0.011</td><td>0.014</td></tr><tr><td>SEC</td><td>0.469</td><td>0.849</td><td>0.745</td><td>0.849</td><td>0.498</td><td>0.069</td></tr><tr><td>LDMGI</td><td>0.761</td><td>0.888</td><td>0.518</td><td>0.945</td><td>0.523</td><td>0.382</td></tr><tr><td>GDL</td><td>n/a</td><td>0.958</td><td>0.655</td><td>0.924</td><td>0.401</td><td>0.020</td></tr><tr><td>RCC</td><td>0.893</td><td>0.957</td><td>0.836</td><td>0.975</td><td>0.556</td><td>0.138</td></tr><tr><td>RCC-DR</td><td>0.828</td><td>0.957</td><td>0.874</td><td>0.974</td><td>0.553</td><td>0.442</td></tr><tr><td colspan="7">Fully-connected</td></tr><tr><td>DCN</td><td>0.570</td><td>0.810</td><td>0.790</td><td>0.590</td><td>0.430</td><td>0.470</td></tr><tr><td>DEC</td><td>0.840</td><td>0.611</td><td>0.807</td><td>0.000</td><td>0.397</td><td>0.500</td></tr><tr><td>DCC</td><td>0.912</td><td>0.952</td><td>0.877</td><td>0.955</td><td>0.572</td><td>0.495</td></tr><tr><td colspan="7">Convolutional</td></tr><tr><td>JULE</td><td>0.900</td><td>0.979</td><td>0.574</td><td>0.990</td><td></td><td></td></tr><tr><td>DEPICT</td><td>0.919</td><td>0.667</td><td>0.785</td><td>0.989</td><td></td><td></td></tr><tr><td>DCC</td><td>0.913</td><td>0.962</td><td>0.903</td><td>0.985</td><td></td><td></td></tr></table>
+
+Table 1: Clustering accuracy of DCC and 12 baselines, measured by AMI. Higher is better. Methods that do no use deep networks are listed first, followed by deep clustering algorithms that use fullyconnected autoencoders (including the fully-connected configuration of DCC) and deep clustering algorithms that use convolutional autoencoders (including the convolutional configuration of DCC). Results that are within $1 \%$ of the highest accuracy achieved by any method are highlighted in bold. DCC performs on par or better than prior deep clustering formulations, without relying on a priori knowledge of the number of ground-truth clusters.
+
+# 5 ANALYSIS
+
+Importance of joint optimization. We now analyze the importance of performing dimensionality reduction and clustering jointly, versus performing dimensionality reduction and then clustering the embedded data. To this end, we use the same SDAE architecture and training procedure as fully-connected DCC. We optimize the autoencoder but do not optimize the full DCC objective. This yields a standard nonlinear embedding, using the same autoencoder that is used by DCC, into a space with the same reduced dimensionality $d$ . In this space, we apply a number of clustering algorithms: $k$ -means $^ { + + }$ , AC-W, DBSCAN, SEC, LDMGI, GDL, and RCC. The results are shown in Table 2 (top).
+
+These results should be compared to results reported in Table 1. The comparison shows that the accuracy of the baseline algorithms benefits from dimensionality reduction. However, in all cases their accuracy is still lower than that attained by DCC using joint optimization. Furthermore, although RCC and DCC share the same underlying nearest-neighbor graph construction and a similar clustering loss, the performance of DCC far surpasses that achieved by stagewise SDAE embedding followed by RCC. Note also that the relative performance of most baselines drops on Coil100 and YaleB. We hypothesize that the fully-connected SDAE is limited in its ability to discover a good low-dimensional embedding for very high-dimensional image datasets (tens of thousands of dimensions for Coil100 and YaleB).
+
+Next, we show the performance of the same clustering algorithms when they are applied in the reduced space produced by DCC. These results are reported in Table 2 (bottom). In comparison to Table 2 (top), the performance of all algorithms improves significantly and some results are now on par or better than the results of DCC as reported in Table 1. The improvement for $k$ -means $^ { + + }$ Ward, and DBSCAN is particularly striking. This indicates that the performance of many clustering algorithms can be improved by first optimizing a low-dimensional embedding using DCC and then clustering in the learned embedding space.
+
+<table><tr><td>Dataset</td><td>k-means++</td><td>AC-W</td><td>DBSCAN</td><td>SEC</td><td>LDMGI</td><td>GDL</td><td>RCC</td><td>DCC</td></tr><tr><td colspan="9">Clustering in a reduced space learned by SDAE</td></tr><tr><td>MNIST</td><td>0.669</td><td>0.784</td><td>0.115</td><td>n/a</td><td>0.828</td><td>n/a</td><td>0.881</td><td>0.912</td></tr><tr><td>Coil100</td><td>0.333</td><td>0.336</td><td>0.170</td><td>0.384</td><td>0.318</td><td>0.335</td><td>0.589</td><td>0.952</td></tr><tr><td>YTF</td><td>0.764</td><td>0.831</td><td>0.595</td><td>0.527</td><td>0.612</td><td>0.699</td><td>0.827</td><td>0.877</td></tr><tr><td>YaleB</td><td>0.673</td><td>0.688</td><td>0.503</td><td>0.493</td><td>0.676</td><td>0.742</td><td>0.812</td><td>0.955</td></tr><tr><td>Reuters</td><td>0.501</td><td>0.494</td><td>0.042</td><td>0.435</td><td>0.517</td><td>0.488</td><td>0.542</td><td>0.572</td></tr><tr><td>RCV1</td><td>0.454</td><td>0.430</td><td>0.075</td><td>0.442</td><td>0.060</td><td>0.055</td><td>0.410</td><td>0.495</td></tr><tr><td colspan="9">Clustering in a reduced space learned by DCC</td></tr><tr><td>MNIST</td><td>0.880</td><td>0.883</td><td>0.890</td><td>n/a</td><td>0.868</td><td>n/a</td><td>0.912</td><td>0.912</td></tr><tr><td>Coil100</td><td>0.947</td><td>0.947</td><td>0.569</td><td>0.604</td><td>0.919</td><td>0.915</td><td>0.891</td><td>0.952</td></tr><tr><td>YTF</td><td>0.845</td><td>0.841</td><td>0.896</td><td>0.586</td><td>0.762</td><td>0.658</td><td>0.879</td><td>0.877</td></tr><tr><td>YaleB</td><td>0.811</td><td>0.809</td><td>0.809</td><td>0.584</td><td>0.815</td><td>0.660</td><td>0.814</td><td>0.955</td></tr><tr><td>Reuters</td><td>0.553</td><td>0.554</td><td>0.560</td><td>0.479</td><td>0.586</td><td>0.401</td><td>0.581</td><td>0.572</td></tr><tr><td>RCV1</td><td>0.536</td><td>0.472</td><td>0.496</td><td>0.452</td><td>0.178</td><td>0.326</td><td>0.474</td><td>0.495</td></tr></table>
+
+Table 2: Importance of joint optimization. This table shows the accuracy (AMI) achieved by running prior clustering algorithms on a low-dimensional embedding of the data. For reference, DCC results from Table 1 are also listed. Top: The embedding is performed using the same autoencoder architecture as used by fully-connected DCC, into the same target space. However, dimensionality reduction and clustering are performed separately. Clustering accuracy is much lower than the accuracy achieved by DCC. Bottom: Here clustering is performed in the reduced space discovered by DCC. The performance of all clustering algorithms improves significantly.
+
+Visualization. A visualization is provided in Figure 1. Here we used Barnes-Hut t-SNE (van der Maaten & Hinton, 2008; van der Maaten, 2014) to visualize a randomly sampled subset of 10K datapoints from the MNIST dataset. We show the original dataset, the dataset embedded by the SDAE into $\mathbb { R } ^ { d }$ (optimized for dimensionality reduction), and the embedding into $\mathbb { R } ^ { d }$ produced by DCC. As shown in the figure, the embedding produced by DCC is characterized by well-defined, clearly separated clusters. The clusters strongly correspond to the ground-truth classes (coded by color in the figure), but were discovered with no supervision.
+
+![](images/84f1886a5b0333f2664e8a7f3b5a3771f6db9d2bf54131d93821565f9213f235.jpg)  
+Figure 1: Effect of joint dimensionality reduction and clustering on the embedding. (a) A randomly sampled subset of 10K points from the MNIST dataset, visualized using t-SNE. (b) An embedding of these points into $\mathbb { R } ^ { d }$ , performed by an SDAE that is optimized for dimensionality reduction. (c) An embedding of the same points by the same network, optimized with the DCC objective. When optimized for joint dimensionality reduction and clustering, the network produces an embedding with clearly separated clusters. Best viewed in color.
+
+Robustness to dimensionality of the latent space. Next we study the robustness of DCC to the dimensionality $d$ of the latent space. For this experiment, we consider fully-connected DCC. We vary $d$ between 5 and 60 and measure AMI on the MNIST and Reuters datasets. For comparison, we report the performance of DEC, which uses the same autoencoder architecture, as well as the accuracy attained by running $k$ -means $^ { + + }$ on the output of the SDAE, optimized for dimensionality reduction. The results are shown in Figure 2.
+
+![](images/79c6d1e411b28f9ee42f4ef94bc6f56620b29ef4eaa55555b19d53dac97c81a5.jpg)  
+Figure 2: Robustness to dimensionality of the latent space. Clustering accuracy (AMI) as a function of the dimensionality $d$ . Best viewed in color.
+
+The results yield two conclusions. First, the accuracy of DCC, DEC, and $\mathrm { S D A E } { + } k$ -means gradually decreases as the dimensionality $d$ increases. This supports the common view that clustering becomes progressively harder as the dimensionality of the data increases. Second, the results demonstrate that DCC is more robust to increased dimensionality than DEC and SDAE. For example, on MNIST, as the dimensionality $d$ changes from 5 to 60, the accuracy of DEC and SDAE drops by $28 \%$ and $3 5 \%$ , respectively, while the accuracy of DCC decreases by only $9 \%$ . When $d = 6 0$ , the accuracy attained by DCC is higher than the accuracy attained by DEC and SDAE by $27 \%$ and $40 \%$ , respectively.
+
+# 6 CONCLUSION
+
+We have presented a clustering algorithm that combines nonlinear dimensionality reduction and clustering. Dimensionality reduction is performed by a deep network that embeds the data into a lower-dimensional space. The embedding is optimized as part of the clustering process and the resulting network produces clustered data. The presented algorithm does not rely on a priori knowledge of the number of ground-truth clusters. Nonlinear dimensionality reduction and clustering are performed by optimizing a global continuous objective using scalable gradient-based solvers.
+
+# REFERENCES
+
+David Arthur and Sergei Vassilvitskii. k-means $^ { + + }$ : The advantages of careful seeding. In Symposium on Discrete Algorithms (SODA), 2007.
+
+Keith Ball. An elementary introduction to modern convex geometry. In Flavors of Geometry. 1997.
+
+Arindam Banerjee, Srujana Merugu, Inderjit S. Dhillon, and Joydeep Ghosh. Clustering with Bregman divergences. Journal of Machine Learning Research (JMLR), 6, 2005.
+
+Kevin S. Beyer, Jonathan Goldstein, Raghu Ramakrishnan, and Uri Shaft. When is “nearest neighbor” meaningful? In International Conference on Database Theory (ICDT), 1999.
+
+Andrew Blake and Andrew Zisserman. Visual Reconstruction. MIT Press, 1987.
+
+Leon Bottou and Yoshua Bengio. Convergence properties of the´ $\mathbf { k }$ -means algorithms. In Neural Information Processing Systems (NIPS), 1994.
+
+M.R. Brito, E.L. Chavez, A.J. Quiroz, and J.E. Yukich. Connectivity of the mutual k-nearest-neighbor ´ graph in clustering and outlier detection. Statistics & Probability Letters, 35, 1997.
+
+Kamran Ghasedi Dizaji, Amirhossein Herandi, Cheng Deng, Weidong Cai, and Heng Huang. Deep clustering via joint convolutional autoencoder embedding and relative entropy minimization. In International Conference on Computer Vision (ICCV), 2017.
+
+Martin Ester, Hans-Peter Kriegel, Jorg Sander, and Xiaowei Xu. A density-based algorithm for ¨ discovering clusters in large spatial databases with noise. In Knowledge Discovery and Data Mining (KDD), 1996.
+
+Stuart Geman and Donald E. McClure. Statistical methods for tomographic image reconstruction. Bulletin of the International Statistical Institute, 52, 1987.
+
+Athinodoros S. Georghiades, Peter N. Belhumeur, and David J. Kriegman. From few to many: Illumination cone models for face recognition under variable lighting and pose. Pattern Analysis and Machine Intelligence (PAMI), 23(6), 2001.
+
+Geoffrey E. Hinton and Ruslan Salakhutdinov. Reducing the dimensionality of data with neural networks. Science, 313(5786), 2006.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. In International Conference on Machine Learning (ICML), 2015.
+
+Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In International Conference on Learning Representations (ICLR), 2015.
+
+Hans-Peter Kriegel, Peer Kroger, and Arthur Zimek. Clustering high-dimensional data: A survey on ¨ subspace clustering, pattern-based clustering, and correlation clustering. ACM Transactions on Knowledge Discovery from Data, 3(1), 2009.
+
+Yann LeCun, Leon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to ´ document recognition. Proceedings of the IEEE, 86(11), 1998.
+
+David D. Lewis, Yiming Yang, Tony G. Rose, and Fan Li. RCV1: A new benchmark collection for text categorization research. Journal of Machine Learning Research (JMLR), 5, 2004.
+
+Hossein Mobahi and John W. Fisher III. A theoretical analysis of optimization by Gaussian continuation. In AAAI, 2015.
+
+Vinod Nair and Geoffrey E. Hinton. Rectified linear units improve restricted Boltzmann machines. In International Conference on Machine Learning (ICML), 2010.
+
+Sameer A. Nene, Shree K. Nayar, and Hiroshi Murase. Columbia object image library (COIL-100). Technical Report CUCS-006-96, Columbia University, 1996.
+
+Andrew Y. Ng, Michael I. Jordan, and Yair Weiss. On spectral clustering: Analysis and an algorithm. In Neural Information Processing Systems (NIPS), 2001.
+
+Feiping Nie, Zinan Zeng, Ivor W. Tsang, Dong Xu, and Changshui Zhang. Spectral embedded clustering: A framework for in-sample and out-of-sample spectral clustering. IEEE Transactions on Neural Networks, 22(11), 2011.
+
+Sohil Atul Shah and Vladlen Koltun. Robust continuous clustering. Proceedings of the National Academy of Sciences (PNAS), 114(37), 2017.
+
+Nitish Srivastava, Geoffrey E. Hinton, Alex Krizhevsky, Ilya Sutskever, and Ruslan Salakhutdinov. Dropout: A simple way to prevent neural networks from overfitting. Journal of Machine Learning Research (JMLR), 15(1), 2014.
+
+Michael Steinbach, Levent Ertoz, and Vipin Kumar. The challenges of clustering high dimensional ¨ data. In New Directions in Statistical Physics. 2004.
+
+Alexander Strehl and Joydeep Ghosh. Cluster ensembles – A knowledge reuse framework for combining multiple partitions. Journal of Machine Learning Research (JMLR), 3, 2002.
+
+Marc Teboulle. A unified continuous optimization framework for center-based clustering methods. Journal of Machine Learning Research (JMLR), 8, 2007.
+
+Laurens van der Maaten. Learning a parametric embedding by preserving local structure. In International Conference on Artificial Intelligence and Statistics (AISTATS), 2009.
+
+Laurens van der Maaten. Accelerating t-SNE using tree-based algorithms. Journal of Machine Learning Research (JMLR), 15, 2014.
+
+Laurens van der Maaten and Geoffrey E. Hinton. Visualizing high-dimensional data using t-SNE. Journal of Machine Learning Research (JMLR), 9, 2008.
+
+Laurens van der Maaten, Eric Postma, and Jaap van den Herik. Dimensionality reduction: A comparative review. Technical Report TiCC-TR 2009-005, Tilburg University, 2009.
+
+Rene Vidal. Subspace clustering. ´ IEEE Signal Processing Magazine, 28(2), 2011.
+
+Pascal Vincent, Hugo Larochelle, Isabelle Lajoie, Yoshua Bengio, and Pierre-Antoine Manzagol. Stacked denoising autoencoders: Learning useful representations in a deep network with a local denoising criterion. Journal of Machine Learning Research (JMLR), 11, 2010.
+
+Nguyen Xuan Vinh, Julien Epps, and James Bailey. Information theoretic measures for clusterings comparison: Variants, properties, normalization and correction for chance. Journal of Machine Learning Research (JMLR), 11, 2010.
+
+Ulrike von Luxburg. A tutorial on spectral clustering. Statistics and Computing, 17(4), 2007.
+
+Lior Wolf, Tal Hassner, and Itay Maoz. Face recognition in unconstrained videos with matched background similarity. In Computer Vision and Pattern Recognition (CVPR), 2011.
+
+Junyuan Xie, Ross B. Girshick, and Ali Farhadi. Unsupervised deep embedding for clustering analysis. In International Conference on Machine Learning (ICML), 2016.
+
+Bo Yang, Xiao Fu, Nicholas D. Sidiropoulos, and Mingyi Hong. Towards k-means-friendly spaces: Simultaneous deep learning and clustering. In International Conference on Machine Learning (ICML), 2017.
+
+Jianwei Yang, Devi Parikh, and Dhruv Batra. Joint unsupervised learning of deep representations and image clusters. In Computer Vision and Pattern Recognition (CVPR), 2016.
+
+Yi Yang, Dong Xu, Feiping Nie, Shuicheng Yan, and Yueting Zhuang. Image clustering using local discriminant models and global integration. IEEE Transactions on Image Processing, 19(10), 2010.
+
+Wei Zhang, Xiaogang Wang, Deli Zhao, and Xiaoou Tang. Graph degree linkage: Agglomerative clustering on a directed graph. In European Conference on Computer Vision (ECCV), 2012.
+
+# APPENDIX
+
+# A DATASETS
+
+MNIST (LeCun et al., 1998): This is a popular dataset containing 70,000 images of handwritten digits. Each image is of size $2 8 \times 2 8$ (784 dimensions). The data is categorized into 10 classes.
+
+Coil100 (Nene et al., 1996): This dataset consists of 7,200 images of 100 object categories, each captured from 72 poses. Each RGB image is of size $1 2 8 \times 1 2 8$ (49,152 dimensions).
+
+YouTube Faces (Wolf et al., 2011): The YTF dataset contains videos of faces. We use all the video frames of the first 40 subjects sorted in chronological order. Each frame is an RGB image of size $5 5 \times 5 5$ . The number of datapoints is 10,056 and the dimensionality is 9,075.
+
+YaleB (Georghiades et al., 2001): This dataset contains 2,414 images of faces of 28 human subjects taken under different lightning condition. Each image is of size $1 9 2 \times 1 6 8$ (32,256 dimensions).
+
+Reuters: This is a popular dataset comprising 21,578 Reuters news articles. We consider the Modified Apte split, which yields a total of 9,082 articles. TF-IDF features on the 2,000 most frequently occurring word stems are computed and normalized. The dimensionality of the data is thus 2,000.
+
+RCV1 (Lewis et al., 2004): This is a document dataset comprising 800,000 Reuters newswire articles. Only the four root categories are considered and all articles labeled with more than one root category are pruned. We report results on a randomly sampled subset of 10,000 articles. 2,000 TF-IDF features were extracted as in the case of the Reuters dataset.
+
+# B CONVOLUTIONAL NETWORK ARCHITECTURE
+
+Table 3 summarizes the architecture of the convolutional encoder used for the convolutional configuration of DCC. Convolutional kernels are applied with a stride of two. The encoder is followed by a fully-connected layer with output dimension $d$ and a convolutional decoder with kernel size that matches the output dimension of conv5. The decoder architecture mirrors the encoder and the output from each layer is appropriately zero-padded to match the input size of the corresponding encoding layer. All convolutional and transposed convolutional layers are followed by batch normalization and rectified linear units (Ioffe & Szegedy, 2015; Nair & Hinton, 2010).
+
+Table 3: Convolutional encoder architecture.   
+
+<table><tr><td></td><td>MNIST</td><td>Coil100</td><td>YTF</td><td>YaleB</td></tr><tr><td>conv1</td><td>4×4</td><td>4×4</td><td>4×4</td><td>4×4</td></tr><tr><td>conv2</td><td>5×5</td><td>5×5</td><td>5×5</td><td>5×5</td></tr><tr><td>conv3</td><td>5×5</td><td>5×5</td><td>5×5</td><td>5×5</td></tr><tr><td>conv4</td><td>1</td><td>5×5</td><td>5×5</td><td>5×5</td></tr><tr><td>conv5</td><td>1</td><td>5×5</td><td>1</td><td>5×5</td></tr><tr><td>output</td><td>4×4</td><td>4×4</td><td>4×4</td><td>6×6</td></tr></table>
+
+# C HYPERPARAMETERS
+
+DCC uses three hyperparameters: the nearest neighbor graph (mkNN) parameter $k$ , the embedding dimensionality $d$ , and the update period $M$ for graduated nonconvexity. For fair comparison to RCC and RCC-DR, we fix $k = 1 0$ (the setting used in Shah & Koltun (2017)). The other two hyperparameters were set to $d = 1 0$ and $M = 2 0$ based on grid search on MNIST. The hyperparameters are fixed at these values across all datasets. No dataset-specific tuning is done. However, note that the hyperparameter $M$ is architecture-specific. We set $M = 1 0$ for convolutional autoencoders and it is varied for varying dimensionality $d$ during the controlled experiment reported in Figures 2 and 3. The other hyperparameters such as $\lambda , \delta _ { i } , \mu _ { i }$ are set automatically as described in Sections 3.2 and 3.3 and in Shah & Koltun (2017).
+
+# D ACC MEASURE
+
+For completeness, we report results according to the ACC measure. Table 4 provides the ACC counterpart to Table 1. Figure 3 provides the ACC counterpart to Figure 2.
+
+![](images/b838c3a50548ae1f08e98f9c4463720173e59ef8bcb61b037a0809d2557070ad.jpg)  
+Figure 3: Clustering accuracy (ACC) as a function of the dimensionality $d$ of the latent space. This is the ACC counterpart to Figure 2. Best viewed in color.
+
+<table><tr><td>Algorithm</td><td>MNIST</td><td>Coil100</td><td>YTF</td><td>YaleB</td><td>Reuters</td><td>RCV1</td></tr><tr><td>k-means++</td><td>0.532</td><td>0.621</td><td>0.624</td><td>0.514</td><td>0.236</td><td>0.529</td></tr><tr><td>AC-W</td><td>0.571</td><td>0.697</td><td>0.647</td><td>0.614</td><td>0.261</td><td>0.554</td></tr><tr><td>DBSCAN</td><td>0.000</td><td>0.921</td><td>0.675</td><td>0.632</td><td>0.700</td><td>0.571</td></tr><tr><td>SEC</td><td>0.545</td><td>0.648</td><td>0.562</td><td>0.721</td><td>0.434</td><td>0.425</td></tr><tr><td>LDMGI</td><td>0.723</td><td>0.763</td><td>0.332</td><td>0.901</td><td>0.465</td><td>0.667</td></tr><tr><td>GDL</td><td>n/a</td><td>0.825</td><td>0.497</td><td>0.783</td><td>0.463</td><td>0.444</td></tr><tr><td>RCC</td><td>0.876</td><td>0.831</td><td>0.484</td><td>0.939</td><td>0.381</td><td>0.356</td></tr><tr><td>RCC-DR</td><td>0.698</td><td>0.825</td><td>0.579</td><td>0.945</td><td>0.437</td><td>0.676</td></tr><tr><td colspan="7">Fully Connected</td></tr><tr><td>DCN</td><td>0.560</td><td>0.620</td><td>0.620</td><td>0.430</td><td>0.220</td><td>0.730</td></tr><tr><td>DEC</td><td>0.867</td><td>0.815</td><td>0.643</td><td>0.027</td><td>0.168</td><td>0.683</td></tr><tr><td>DCC</td><td>0.962</td><td>0.842</td><td>0.605</td><td>0.861</td><td>0.596</td><td>0.563</td></tr><tr><td colspan="7">Fully Convolutional</td></tr><tr><td>JULE</td><td>0.800</td><td>0.911</td><td>0.342</td><td>0.970</td><td></td><td></td></tr><tr><td>DEPICT</td><td>0.968</td><td>0.420</td><td>0.586</td><td>0.965</td><td></td><td></td></tr><tr><td>DCC</td><td>0.963</td><td>0.858</td><td>0.699</td><td>0.964</td><td></td><td></td></tr></table>
+
+Table 4: Clustering accuracy of DCC and 12 baselines, measured by ACC. Higher is better. This is the ACC counterpart to Table 1.
+
+# E NMI MEASURE
+
+We also report results according to the NMI measure. Table 5 provides the NMI counterpart to Table 1.   
+
+<table><tr><td>Algorithm</td><td>MNIST</td><td>Coil100</td><td>YTF</td><td>YaleB</td><td>Reuters</td><td>RCV1</td></tr><tr><td>k-means++</td><td>0.500</td><td>0.835</td><td>0.788</td><td>0.650</td><td>0.536</td><td>0.355</td></tr><tr><td>AC-W</td><td>0.679</td><td>0.876</td><td>0.806</td><td>0.788</td><td>0.492</td><td>0.364</td></tr><tr><td>DBSCAN</td><td>0.000</td><td>0.458</td><td>0.756</td><td>0.535</td><td>0.022</td><td>0.017</td></tr><tr><td>SEC</td><td>0.469</td><td>0.872</td><td>0.760</td><td>0.863</td><td>0.498</td><td>0.069</td></tr><tr><td>LDMGI</td><td>0.761</td><td>0.906</td><td>0.532</td><td>0.950</td><td>0.523</td><td>0.382</td></tr><tr><td>GDL</td><td>n/a</td><td>0.965</td><td>0.664</td><td>0.931</td><td>0.401</td><td>0.020</td></tr><tr><td>RCC</td><td>0.893</td><td>0.963</td><td>0.850</td><td>0.978</td><td>0.556</td><td>0.138</td></tr><tr><td>RCC-DR</td><td>0.827</td><td>0.963</td><td>0.882</td><td>0.976</td><td>0.553</td><td>0.442</td></tr><tr><td colspan="7">Fully-connected</td></tr><tr><td>DCN</td><td>0.570</td><td>0.830</td><td>0.810</td><td>0.630</td><td>0.460</td><td>0.470</td></tr><tr><td>DEC</td><td>0.853</td><td>0.645</td><td>0.811</td><td>0.000</td><td>0.409</td><td>0.504</td></tr><tr><td>DCC</td><td>0.912</td><td>0.961</td><td>0.886</td><td>0.959</td><td>0.588</td><td>0.498</td></tr><tr><td colspan="7">Convolutional</td></tr><tr><td>JULE</td><td>0.900</td><td>0.983</td><td>0.587</td><td>0.991</td><td></td><td></td></tr><tr><td>DEPICT</td><td>0.919</td><td>0.678</td><td>0.790</td><td>0.990</td><td></td><td></td></tr><tr><td>DCC</td><td>0.915</td><td>0.967</td><td>0.908</td><td>0.987</td><td></td><td></td></tr></table>
+
+Table 5: Clustering accuracy of DCC and 12 baselines, measured by NMI. Higher is better. This is the NMI counterpart to Table 1.

parse/train/sUgpxb9QD/sUgpxb9QD.md

@@ -0,0 +1,447 @@
+# SOSP: Efficiently Capturing Global Correlations by Second-Order Structured Pruning
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+Pruning neural networks reduces inference time and memory cost, as well as accelerates training when done at initialization. On standard hardware, these benefits will be especially prominent if coarse-grained structures, like feature maps, are pruned. We devise global saliency-based methods for second-order structured pruning (SOSP) which include correlations among structures, whereas highest efficiency is achieved by saliency approximations using fast Hessian-vector products. We achieve state-of-the-art results for various object classification benchmarks, especially for large pruning rates highly relevant for resource-constrained applications. We showcase that our approach scales to large-scale vision tasks, even though it captures correlations across all layers of the network. Further, we highlight two outstanding features of our methods. First, to reduce training costs our pruning objectives can also be applied at initialization with no or only minor degradation in accuracy compared to pruning after pretraining. Second, our structured pruning methods allow to reveal architectural bottlenecks, which we remove to further increase the accuracy of the networks.
+
+# 16 1 Introduction
+
+17 Deep neural networks have consistently grown in size over the last years with increasing performance.   
+18 However, this increase in size leads to slower inference, higher computational requirements and   
+19 higher cost. To reduce the size of the networks without affecting their performance, a large number   
+20 of pruning algorithms have been proposed (e.g., LeCun et al., 1990; Hassibi et al., 1993; Reed, 1993;   
+21 Han et al., 2015; Blalock et al., 2020). Pruning can either be unstructured, i.e. removing individual   
+22 weights, or structured, i.e. removing entire substructures like nodes or channels. Single-shot pruning   
+23 methods, as investigated in this work, usually consist of three steps: 1) training, 2) pruning, 3) another   
+24 training step often referred to as fine-tuning.   
+25 Unstructured pruning can significantly reduce the number of parameters of a neural network with   
+26 only little loss in the accuracy, but the resulting networks often show only a marginal improvement in   
+27 training and inference time, unless specialized hardware is used (He et al., 2017). In contrast, struc  
+28 tured pruning can directly reduce inference time and even training time when applied at initialization   
+29 (Lee et al., 2018). To exploit these advantages, in this work, we focus on structured pruning.   
+30 Most sensitivity-based pruning methods such as OBD (e.g., LeCun et al., 1990) or C-OBD (Wang   
+31 et al., 2019a) evaluate the effect of removing a single weight or structure on the loss of the neural   
+32 network, while neglecting possible correlations between different structures and within the structures   
+33 themselves. This can significantly harm the estimation of the sensitivities. We take these correlations   
+34 into account by applying efficient second-order estimations that not only consider the diagonal terms   
+35 of the Hessian, but also all off-diagonal terms.   
+36 Global pruning removes structure by structure from all available structures of a network until a   
+37 predefined percentage of pruned structures is reached. Recent examples for global structured pruning   
+38 methods are NN Slimming (Liu et al., 2017), C-OBD and EigenGamage (Wang et al., 2019a). Local   
+39 pruning, on the other hand, first subdivides all global structures into subsets (e.g. layers) and removes   
+40 a percentage of structures of each subset. Recent examples for local pruning methods are HRank   
+41 (Lin et al., 2019), CCP (Peng et al., 2019), FPGM (He et al., 2019) and Variational Pruning (Zhao   
+42 et al., 2019). Most local pruning schemes use a predefined layer-wise pruning ratio, which fixes the   
+43 percentage of structures removed per layer. While this approach prevents the layers from collapsing,   
+44 it also reduces some of the degrees of freedom, since some layers may be less important than others.   
+45 Our main goal in this work is to devise a simple and efficient second-order pruning method, which   
+46 considers all global correlations for structured sensitivity pruning. In addition, we want to highlight   
+47 the benefits that such methods may have over other structured global and local pruning schemes.
+
+48 Our contributions are as follows:
+
+• We introduce two novel saliency-based methods for second-order structured pruning (SOSP), which consider all correlations across structures and layers. We benchmark our SOSP methods against a variety of state-of-the-art pruning methods on several networks and datasets and achieve comparable or better results at low computational costs. • We show that our pruning methods can also be applied at initialization almost matching the performance of pruning after training and significantly reducing the cost of network training. • We exploit the structure of the pruning masks found by our SOSP methods to remove architectural bottlenecks, which further improves the performance of the pruned networks. In this work, we consider layers with disproportionally low pruning ratios architectural bottlenecks.
+
+PyTorch code implementing our method is attached in the Supplementary Material and we will publish the code upon acceptance of this manuscript.
+
+# 61 2 SOSP: Second-order structured pruning
+
+62 A neural network (NN) maps an input $x \in \mathbb { R } ^ { d }$ to an output $f _ { \theta } ( x ) \in \mathbb { R } ^ { D }$ , where $\theta \in \mathbb { R } ^ { P }$ are its   
+63 64 $P$ parameters. NN training proceeds, after random intch stochastic gradient descent on the empirical loss $\begin{array} { r } { \mathcal { L } ( \boldsymbol { \theta } ) : = \frac { 1 } { N } \sum _ { n = 1 } ^ { N } \ell \left( f _ { \boldsymbol { \theta } } ( x _ { n } ) , y _ { n } \right) } \end{array}$ $\theta = \theta _ { 0 }$ s, by mini-, given the   
+65 training dataset . In the classification case, $y \in \{ 1 , \ldots , D \}$ is a discrete   
+66 ground-truth label and $\ell ( f _ { \theta } ( x ) , y ) : = - \log \sigma \left( f _ { \theta } ( x ) \right) _ { y }$ the cross-entropy loss, with $\overset { \prime } { \sigma } : \mathbb { R } ^ { D }  \mathbb { R } ^ { D }$
+
+the softmax-function. For regression, 67 $\boldsymbol { y } \in \mathbb { R } ^ { D }$ and $\begin{array} { r } { \ell ( f _ { \theta } ( x ) , y ) = \frac { 1 } { 2 } \left\| f _ { \theta } ( x ) - y \right\| ^ { 2 } } \end{array}$ is the squared loss.
+
+68 Structured pruning aims to remove weights or rather entire structures from a $\Nu { \cal f } _ { \theta }$ with parameters   
+69 $\theta$ . A structure can be a filter (channel) in a convolutional layer, a neuron in a fully-connected layer, or   
+70 an entire layer in a parallel architecture. We assume the NN in question has been segmented into   
+71 $S$ structures $s = 1 , \ldots , S$ , which can potentially be pruned. We define the notation $\boldsymbol { \theta _ { s } } ^ { \mathbf { \bar { \theta } } } \in \mathbb { R } ^ { P }$ as the   
+72 vector whose only nonzero components are those weights from $\theta$ that belong to structure $s$ .1 Then, a   
+73 pruning mask is a set $M = \{ s _ { 1 } , \ldots , s _ { m } \}$ of structures. Applying a mask $M$ to a NN $f _ { \theta }$ means to   
+74 consider the NN with parameter vector $\begin{array} { r } { \dot { \theta _ { \setminus M } } : = \theta - \sum _ { s \in M } \bar { \theta } _ { s } } \end{array}$ .2   
+75 We now develop our pruning methods that incorporate global correlations into their saliency as  
+76 sessment by efficiently including the second-order loss terms. The first method (SOSP-I) admits a   
+77 direct interpretation in terms of individual loss sensitivities, while the second (SOSP-H) remains very   
+78 efficient for the largest networks due to its Hessian-vector product approximation.   
+79 The basic idea behind both our pruning methods is to select the pruning mask $M$ so as to (approxi  
+80 mately) minimize the joint effect on the network loss
+
+$$
+\lambda ( M ) : = \left| \mathcal { L } ( \boldsymbol { \theta } ) - \mathcal { L } ( \boldsymbol { \theta } _ { \setminus M } ) \right|
+$$
+
+81 of removing all structures in $M$ , subject to a constraint on the overall pruning ratio. To circumvent   
+82 this exponentially large search space, we approximate the loss up to second order, so that
+
+$$
+\lambda _ { 2 } ( M ) = \left| \sum _ { s \in M } \theta _ { s } ^ { T } \frac { d \mathcal { L } ( \theta ) } { d \theta } - \frac { 1 } { 2 } \sum _ { s , s ^ { \prime } \in M } \theta _ { s } ^ { T } \frac { d ^ { 2 } \mathcal { L } ( \theta ) } { d \theta d \theta ^ { T } } \theta _ { s ^ { \prime } } \right|
+$$
+
+83 collapses to single-structure contributions plus pairwise correlations; note that the latter include interactions among the weights within a single 84 $s = s ^ { \prime }$ , which can be sizeable for large structures.
+
+85 The first-order terms $\lambda _ { 1 } ( s ) : = \theta _ { s } \cdot d \mathcal { L } ( \theta ) / d \theta \in \mathbb { R } ^ { P }$ in (1) are efficient to evaluate by computing the   
+86 gradient $d { \mathcal { L } } ( \theta ) / d \theta \in \mathbb { R } ^ { P }$ once and then a (sparse) dot product for every $s$ . In contrast to these first  
+87 order terms, the network Hessian $H ( \theta ) : = \bar { d ^ { 2 } } \mathcal { L } ( \theta ) / d \theta ^ { \hat { 2 } } \in \mathbb { R } ^ { P \times P }$ in (1) is prohibitively expensive to   
+88 compute or store in full. We therefore propose two different schemes to efficiently overcome this   
+89 obstacle. Each scheme entails its own way to select the pruning mask. We name the full methods   
+90 SOSP-I (individual sensitivities) and SOSP-H (Hessian-vector product).
+
+# 91 2.1 SOSP-I: Saliency from individual sensitivities
+
+92 SOSP-I approximates each individual term $\theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } }$ in (1) efficiently, as we will show in Eq. (6).   
+93 We can therefore consider a modification of Eq. (1) in which the sensitivity is judged by considering   
+94 all single and pairwise sensitivities individually:
+
+$$
+\lambda _ { 2 } ^ { I } ( M ) = \sum _ { s \in M } \left| \theta _ { s } ^ { T } \frac { d \mathcal { L } ( \theta ) } { d \theta } \right| + \frac { 1 } { 2 } \sum _ { s , s ^ { \prime } \in M } \left| \theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } } \right| .
+$$
+
+95 To avoid cancellations between signed contributions, we take absolute values because this measures   
+96 the strengths of the individual sensitivities $\lambda _ { 1 } ( s )$ and pairwise correlations $\theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } }$ . While   
+97 objectives other than $\lambda _ { 2 } ^ { I }$ are equally possible in the method, including $\lambda _ { 2 }$ and modifications with the   
+98 absolute value not pulled in all the way, we found empirically that $\bar { \lambda _ { 2 } ^ { I } }$ performs best overall.   
+99 Then, SOSP-I iteratively selects the structures to prune, based on the objective (2): Starting from   
+100 an empty pruning mask $M = \{ \}$ , we iteratively add to $M$ the structure $s \notin M$ that minimizes the   
+101 overall sensitivity $\lambda _ { 2 } ^ { I } ( M \cup \{ s \} )$ . In practice, the algorithm pre-computes the matrix $Q \in \mathbb { R } ^ { S \times S }$ ,
+
+$$
+Q _ { s , s ^ { \prime } } : = \frac { 1 } { 2 } \left| \theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } } \right| + \left| \theta _ { s } ^ { T } \frac { d \mathcal { L } ( \theta ) } { d \theta } \right| \cdot \delta _ { s = s ^ { \prime } } ,
+$$
+
+102 and selects at each iteration a structure $s \notin M$ to prune by
+
+$$
+\underset { s \notin { \cal M } } { \arg \operatorname* { m i n } } \lambda _ { 2 } ^ { I } ( { \cal M } \cup s ) - \lambda _ { 2 } ^ { I } ( { \cal M } ) = \underset { s \notin { \cal M } } { \arg \operatorname* { m i n } } \left( Q _ { s , s } + 2 \sum _ { s ^ { \prime } \in { \cal M } } Q _ { s , s ^ { \prime } } \right) ,
+$$
+
+103 terminating at the desired pruning ratio.
+
+104 105 $\begin{array} { r } { \frac { 1 } { N } \sum _ { n } \nabla _ { \theta } ^ { 2 } \ell ( f _ { \theta } \dot { ( x _ { n } ) } , y _ { n } ) } \end{array}$ te the Hessian terms  those terms that involv $\theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } }$ efficiently, we omit from sive second-order derivatives $\nabla _ { { \boldsymbol { \theta } } } ^ { 2 } f _ { \boldsymbol { \theta } } ( { \boldsymbol { x } } _ { n } )$ $\begin{array} { r l } { H ( \theta ) } & { { } = } \end{array}$   
+106 of the NN outputs, while including second-order couplings due to . This is equivalent to approx  
+107 imating $\begin{array} { r } { H ( \theta ) \ \tilde { \ } \approx H ( f _ { \theta } ^ { l i n } ) : = \frac { 1 } { N } \sum _ { n } \nabla _ { \theta } ^ { 2 } \ell ( f _ { \theta } ^ { l i n } ( x _ { n } ) , \tilde { \ y } _ { n } ) } \end{array}$ for the linearized $f _ { \theta ^ { \prime } } ( x ) \approx f _ { \theta ^ { \prime } } ^ { l i n } ( \stackrel { . . . } { x } ) : =$   
+108 $f _ { \theta } ( x ) + \phi ( x ) \cdot ( \theta ^ { \prime } - \theta )$ with $\phi ( { \boldsymbol { x } } ) : = \nabla _ { \theta } f _ { \theta } ( { \boldsymbol { x } } ) \in \mathbb { R } ^ { D \times P }$ , which is well motivated by the NTK limit   
+109 (Jacot et al., 2018) for large NNs at both initialization and after training. The terms in the sum become
+
+$$
+\nabla _ { \boldsymbol { \theta } } ^ { 2 } \ell \left( f _ { \boldsymbol { \theta } } ^ { l i n } ( x _ { n } ) , y _ { n } \right) = \boldsymbol { \phi } ( x _ { n } ) ^ { T } R _ { n } \boldsymbol { \phi } ( x _ { n } ) ,
+$$
+
+110 where $R _ { n } \ \in \ \mathbb { R } ^ { D \times D }$ is diagonal for squared loss, and has an additional rank-1 contribution for   
+111 cross-entropy (see App. B). Similar Hessian approximations were employed before in NNs (Hassibi   
+112 et al., 1993; Wang et al., 2019a; Peng et al., 2019) and also in the Gauss-Newton optimization method   
+113 (Fletcher, 2013). Our final approximation is to use a random subsample of $N ^ { \prime } < N$ data points:
+
+$$
+\theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } } \approx \frac { 1 } { N ^ { \prime } } \sum _ { n = 1 } ^ { N ^ { \prime } } \left( \phi ( x _ { n } ) \theta _ { s } \right) ^ { T } R _ { n } \left( \phi ( x _ { n } ) \theta _ { s ^ { \prime } } \right) .
+$$
+
+114 In practice, one pre-computes all (sparse) products $\phi ( x _ { n } ) \theta _ { s } \in \mathbb { R } ^ { D }$ starting from the efficient gradient   
+115 $\phi ( x _ { n } )$ , before aggregating a batch onto the terms $\theta _ { s } ^ { T } H ( \theta ) \theta _ { s ^ { \prime } }$ . Eq. (6) also has an interpretation as   
+116 output correlations between certain network modifications, without using derivatives (App. C).   
+118 SOSP-H treats the second-order terms in (1) in a way that is motivated by the limit of large pruning   
+119 ratios: At high pruning ratios, the sum $\sum _ { s ^ { \prime } \in M } \theta _ { s ^ { \prime } }$ in (1) can be approximated by $\begin{array} { r } { \sum _ { s ^ { \prime } = 1 } ^ { \bar { S } } \theta _ { s ^ { \prime } } = : } \end{array}$   
+120 $\theta _ { s t r u c }$ (this equals if every NN weight belongs to some structure $s$ ). The second-order term   
+121 $\begin{array} { r } { \sum _ { s , s ^ { \prime } \in M } \theta _ { s } ^ { T } \dot { H ( \theta ) } \theta _ { s ^ { \prime } } \approx \left( \sum _ { s \in M } \theta _ { s } ^ { T } \right) \left( \check { H } ( \theta ) \theta _ { s t r u c } \right) } \end{array}$ 
 thus becomes tractable since the Hessian-vector   
+122 product $H ( \theta ) \theta _ { s t r u c }$ is efficiently computable by a variant of the backpropagation algorithm. To   
+123 account for each structure $s$ and for the first- and second-order contributions separately, as above, we   
+124 place absolute value signes in (1) so as to arrive at the final objective $\begin{array} { r } { \lambda _ { 2 } ^ { H } ( M ) \overset { \cdot } { : = } \sum _ { s \in M } \lambda _ { 2 } ^ { H } ( s ) } \end{array}$ with
+
+$$
+\lambda _ { 2 } ^ { H } ( s ) : = \left| \theta _ { s } ^ { T } \frac { d \mathcal { L } ( \theta ) } { d \theta } \right| + \frac { 1 } { 2 } \left| \theta _ { s } ^ { T } \big ( H ( \theta ) \theta _ { s t r u c } \big ) \right| .
+$$
+
+125 The last term measures the correlations between one structure $s$ and all other prunable structures,   
+126 although some of these may cancel unlike for SOSP-I. To minimize $\lambda _ { 2 } ^ { H } ( M )$ , SOSP-H starts from an   
+127 empty pruning mask $M = \{ \}$ , and successively adds to $M$ a structure $s \notin M$ with smallest $\lambda _ { 2 } ^ { H } ( s )$ .   
+128 Unlike the Gauss-Newton approximation in SOSP-I, SOSP-H uses the exact Hessian $H ( \theta )$ , but can   
+129 therefore not account for individual absolute $s { - } s ^ { \prime }$ -correlations, see Eq. (7) vs. (2). Both methods   
+130 reduce to the same first-order pruning method when neglecting the second order (i.e. $H ( \theta ) : = 0 \rangle$ ).
+
+# 2.3 Computational complexity
+
+132 We detail here the computational complexities of our methods (for the experimental evaluation see   
+133 Sec. 3.2). The approximation of $Q$ in (3) requires complexity $O \left( N ^ { \prime } D ( F + P ) \right) = O ( N ^ { \prime } D F )$ for   
+134 computing all $\bar { \phi ( \boldsymbol { x } _ { n } ) } \theta _ { s }$ , where $F \geq P$ denotes the cost of one forward pass through the network   
+135 $F \approx P$ for fully-connected NNs), plus $O ( N ^ { \prime } D S ^ { 2 } )$ for the sum in (6). This is tractable for modern   
+136 NNs, while including the exact $H ( \theta )$ would have complexity at least $O ( N ^ { \prime } D S F )$ . Once $Q$ has been   
+137 computed, the selection procedure based on (4) has overall complexity ${ \cal O } ( S ^ { 3 } )$ , which is feasible for   
+138 most modern convolutional NNs (Sec. 3.2). The total complexity of the SOSP-I method is thus
+
+$$
+O ( N ^ { \prime } D F ) + O ( N ^ { \prime } D S ^ { 2 } ) + O ( S ^ { 3 } ) .
+$$
+
+139 SOSP-H has computational complexity $O ( N ^ { \prime } D F )$ to compute the sensitivities (7), which is com  
+140 parable to computing the sensitivities $Q$ in SOSP-I when the number of structures is low $( S ^ { 2 } \lesssim F )$ .   
+141 Together with the sorting of the saliency values $\lambda _ { 2 } ^ { H } ( s )$ , the overall complexity of SOSP-H is thus
+
+$$
+O ( N ^ { \prime } D F ) + O ( S \log ( S ) ) .
+$$
+
+142 Due to its weak dependency on $S$ , in practice, SOSP-H efficiently scales to large modern networks   
+143 and may even be used for unstructured second-order pruning, where $S = P$ .   
+144 Both of our methods scale much better than naively including all off-diagonal Hessian terms, which   
+145 is intractable for modern NNs due to its $O ( N ^ { \prime } D \dot { S } F )$ scaling. Since SOSP-I builds on individual   
+146 absolute sensitivities and the established Gauss-Newton approximation, we use SOSP-I in the   
+147 following in particular to validate the more efficient SOSP-H method.
+
+# 148 3 Results
+
+149 To evaluate our methods, we train and prune VGGs (Simonyan & Zisserman, 2014), ResNets (He   
+150 et al., 2016), and DenseNets (Huang et al., 2017) on the Cifar10/100 (Krizhevsky et al., 2009) and   
+151 ImageNet (Deng et al., 2009) datasets. Stochastic gradient descent with an initial learning rate of 0.1,   
+152 a momentum of 0.9 and weight decay of $1 0 ^ { - 4 }$ is used to train these networks. For ResNet-32/56 and   
+153 VGG-Net on Cifar10/100, we use a batch size of 128, train for 200 epochs and reduce the learning rate   
+154 by a factor of 10 after 120 and 160 epochs. To fine-tune the network after pruning, we exactly repeat   
+155 this learning rate schedule. For DenseNet-40 on Cifar10/100, we train for 300 epochs and reduce   
+156 the learning rate after 150 and 225 epochs. For ResNets on ImageNet, we use a batch size of 256,   
+157 train for 128 epochs and use a cosine learning rate decay. For all networks, we prune feature maps   
+158 (i.e. channels) from all layers except the last fully-connected layer; for ResNets, we also exclude the   
+159 downsampling-path from pruning. We approximate the Hessians by a subsample of size $N ^ { \prime } = 1 0 0 0$   
+160 (see Sec. 2.1). We report the best or average final test accuracy over 3 trials if not noted otherwise.   
+161 The experiments were run on an internal cluster with Nvidia Tesla V100 GPUs. Reproducing the   
+162 results presented in this paper would take about 60 days of GPU run-time.
+
+Table 1: Comparison of SOSP to other global pruning methods for high pruning ratios. The comparison for moderate pruning ratios is defered to the appendix (see App. A.1). We tuned our pruning ratios to similar values as reported by the referred methods. To ensure identical implementations of the network models in PyTorch, reference numbers are taken from Wang et al. (2019a) and (Mingjie & Zhuang, 2018). In accordance with all referred methods, we report the mean and standard deviation of the best accuracies observed during fine-tuning. For final accuracies after fine-tuning see App. A.3. \* denotes the baseline model. Both SOSP methods perform either on par or outperform the competing global pruning methods.   
+
+<table><tr><td>Dataset</td><td colspan="3">Cifar10</td><td colspan="3">Cifar100</td></tr><tr><td>Method</td><td>Test acc. (%)</td><td>Reduct. in weights (%)</td><td>Reduct. in MACs (%)</td><td>Test acc. (%)</td><td>Reduct. in weights (%)</td><td>Reduct. in MACs (%)</td></tr><tr><td>VGG-Net*</td><td>94.18</td><td></td><td></td><td>73.45</td><td>=</td><td></td></tr><tr><td>NN Slimming</td><td>85.01</td><td>97.85</td><td>97.89</td><td>58.69</td><td>97.76</td><td>94.09</td></tr><tr><td>NN Slim.+Li</td><td>91.99</td><td>97.93</td><td>86.00</td><td>57.07</td><td>97.59</td><td>93.86</td></tr><tr><td>C-OBD</td><td>92.34 ± 0.18</td><td>97.68 ± 0.02</td><td>77.39 ± 0.36</td><td>58.07 ± 0.60</td><td>97.97 ± 0.04</td><td>77.55 ± 0.25</td></tr><tr><td>EigenDamage</td><td>92.29 ± 0.21</td><td>97.15 ± 0.04</td><td>86.51 ± 0.26</td><td>65.18 ± 0.10</td><td>97.31 ± 0.01</td><td>88.63 ±0.12</td></tr><tr><td>SOSP-I (ours)</td><td>92.62 ± 0.14</td><td>97.79 ± 0.02</td><td>83.52 ±0.29</td><td>64.20 ± 0.23</td><td>97.83 ± 0.04</td><td>87.02 ± 0.20</td></tr><tr><td>SOSP-H(ours)</td><td>92.71 ± 0.19</td><td>97.81 ± 0.01</td><td>86.32 ±0.29</td><td>64.59 ± 0.35</td><td>97.81 ± 0.01</td><td>86.32 ± 0.29</td></tr><tr><td>ResNet-32*</td><td>95.30</td><td></td><td></td><td>76.8</td><td></td><td></td></tr><tr><td>C-OBD</td><td>91.75 ± 0.42</td><td>97.30 ± 0.06</td><td>93.50 ± 0.37</td><td>59.52 ± 0.24</td><td>97.74 ± 0.08</td><td>94.88 ±0.08</td></tr><tr><td>EigenDamage</td><td>93.05 ± 0.23</td><td>96.05 ± 0.03</td><td>94.74 ± 0.02</td><td>65.72 ± 0.04</td><td>95.21 ± 0.04</td><td>94.62 ± 0.06</td></tr><tr><td>SOSP-I(ours)</td><td>92.43 ± 0.09</td><td>95.47 ± 0.33</td><td>94.07 ± 0.66</td><td>67.36 ± 0.46</td><td>92.69 ± 0.07</td><td>95.63 ± 0.13</td></tr><tr><td>SOSP-H(ours)</td><td>92.23 ±0.12</td><td>95.26 ±0.10</td><td>94.45 ±0.40</td><td>68.42 ± 0.21</td><td>94.08 ± 0.21</td><td>95.06 ±0.14</td></tr><tr><td>DenseNet-40*</td><td>94.58</td><td></td><td></td><td>74.11</td><td>=</td><td>=</td></tr><tr><td>NN Slim. + L1</td><td>94.22</td><td>54.21</td><td></td><td>73.19</td><td>54.21</td><td>=</td></tr><tr><td>SOSP-I(ours)</td><td>94.21 ± 0.04</td><td>47.00 ± 0.10</td><td>36.35 ± 0.12</td><td>73.05 ± 0.11</td><td>45.22 ±0.10</td><td>42.05 ±1.16</td></tr><tr><td>SOSP-H(ours)</td><td>94.23 ± 0.05</td><td>49.39 ± 0.65</td><td>38.86 ±0.70</td><td>73.05 ± 0.24</td><td>48.58 ± 0.22</td><td>42.05 ± 0.35</td></tr></table>
+
+![](images/48af209a8c51f5bcc0cf61ffe529ff0027302b639f0fbc2a992cbd6be72f9970.jpg)  
+Figure 1: Comparison of SOSP to local, i.e. layer-wise, pruning methods on Cifar10. The best final test accuracy is plotted over the effective number of model parameters (a, c) and MACs (b, d). A tabular representation as well as statistics across trials are shown in App. A.4. SOSP outperforms all competing layer-wise pruning methods, especially over the number of effective parameters.
+
+# 163 3.1 Comparison to Literature
+
+164 Here we benchmark the performance of our SOSP methods against existing pruning algorithms on   
+165 different datasets and networks. First, we compare against other recent global pruning methods,   
+166 then against local structured pruning methods, i.e. with pre-specified layer-wise pruning rates. In all   
+167 comparisons we report the achieved test accuracy, the number of parameters of the pruned network   
+168 and the MACs (often referred to as FLOPs). To facilitate direct comparisons, we report test accuracies   
+169 in the same way as the competing methods (e.g. best trial or average over trials), but additionally   
+170 report mean and standard deviation of the test error for our models in App. A. Our count of the   
+171 network parameters and MACs is based on the actual pruned network architecture (cf. App. D), even   
+172 though our saliency measure associates with each structure only the weights into this structure.   
+173 We first compare our SOSP methods with global pruning methods on VGG-Net, ResNet-32 and   
+174 DenseNet-40. We use the same variants and implementations of these networks as used by Neural   
+175 Network Slimming (NN Slimming; Liu et al., 2017) as well as EigenDamage and C-OBD (Wang   
+176 et al., 2019a), e.g. capping the layer-wise ratio of removed structures at $9 5 \%$ for VGGs to prevent   
+177 layer collapse and increasing the width of ResNet-32 by a factor 4. C-OBD is a structured variant of   
+178 the original OBD algorithm (Hassibi et al., 1993), which neglects all cross-structure correlations that,   
+179 in contrast, SOSP takes into account. The results over three trials for high pruning ratios are shown in   
+180 Tab. 1 and for moderate pruning ratios in App. A.1. To enable the comparison to NN Slimming on   
+181 an already pretrained VGG, we included the results of NN Slimming applied to a baseline network   
+182 obtained without modifications to its initial training, i.e. without $L _ { 1 }$ -regularization on the batch  
+183 normalization parameters. For moderate pruning rates, all pruning schemes approximately retain the   
+184 baseline performance for VGG-Net and ResNet-32 on Cifar10 and VGG-Net on Cifar100 (see Tab.   
+185 3). The only exception is the accuracy for C-OBD applied to VGG-Net on Cifar100, which drops by   
+186 approximately $1 \%$ . For ResNet-32 on Cifar100 the accuracy after pruning is approximately $1 \%$ lower   
+187 than the baseline, for all pruning schemes. In the regime of larger pruning ratios of approximately $9 7 \%$ ,   
+188 SOSP and EigenDamage significantly outperform NN Slimming and C-OBD. SOSP performs on par   
+189 with EigenDamage, except for ResNet-32 on Cifar100, where SOSP outperforms EigenDamage by   
+190 almost ${ \bar { 3 } } \%$ . This result indicates that SOSP outperforms all other methods especially in the regime of   
+191 baseline networks that have relatively few parameters already and on difficult datasets most relevant   
+192 for applications. For DenseNet-40, we achieve similar results compared to NN Slimming. However,   
+193 note that NN Slimming requires the modification of network pretraining.   
+194 Next, we compare our SOSP methods against four recently published local, i.e. layer-wise, pruning   
+195 algorithms: FPGM He et al. (2019), GAL (Lin et al., 2019), CCP (Peng et al., 2019), Variational   
+196 Pruning (VP; Zhao et al., 2019) and HRank (Lin et al., 2020). For ResNet-56, our SOSP methods   
+197 outperform all other methods across all pruning ratios (see Fig. 1a and b). For DenseNet-40, SOSP   
+198 achieves better accuracies when compared over parameters (Fig. 1c) and is on par with the best other   
+199 methods over MACs (Fig. 1d). The reason for this discrepancy is probably that the SOSP objective is   
+200 agnostic to the number of MACs (image size) in each individual structure.
+
+![](images/483c6c0104155e99ede5d9497d8add4cd19500ef371eda5c32c92b05467714a5.jpg)  
+Figure 2: Runtime to calculate the pruning masks for ResNet-56 on Cifar10 over the width of the network for SOSP-I and SOSP-H. We vary the width of the network by increasing the width of each layer by a multiplicative factor.
+
+Table 2: Best final test accuracies and pruning ratios (PR) across 2 trials on ImageNet. For comparison to CCP, we also provide their alternative MAC count (for details, see App. D). \* denotes SOSP with kernel scaling (see main text). SOSP outperforms all three competing methods.   
+
+<table><tr><td>Model</td><td>Top-1% (Gap)</td><td>Parameters (PR)</td><td>MACs (PR)</td><td>Alt. MACs (PR)</td></tr><tr><td>ResNet-18</td><td>69.76 (0.0)</td><td>11.7M (0%)</td><td>1.82B (0%)</td><td>1.82B (0%)</td></tr><tr><td>SOSP (ours)</td><td>69.63 (0.13)</td><td>7.12M (39%)</td><td>1.37B (24%)</td><td>1.31B (28%)</td></tr><tr><td>FPGM</td><td>68.41 (1.87)</td><td>7.10M (39%)</td><td>1.06B (41%)</td><td></td></tr><tr><td>SOSP (ours)</td><td>68.78 (0.98)</td><td>6.42M (45%)</td><td>1.29B (29%)</td><td>1.20B (34%)</td></tr><tr><td>ResNet-50</td><td>76.15 (0.0)</td><td>25.5M (0%)</td><td>3.85B (0%)</td><td>3.85B (0%)</td></tr><tr><td>SOSP (ours)</td><td>76.56(-0.41)</td><td>19.9M(22%)</td><td>3.06B(21%)</td><td>2.72B(29%)</td></tr><tr><td>SOSP*(ours)</td><td>76.60 (-0.45)</td><td>17.9M (30%)</td><td>2.79B (28%)</td><td>2.47B (36%)</td></tr><tr><td>HRank</td><td>74.98 (1.17)</td><td>16.2M(36%)</td><td>2.30B (44%)</td><td></td></tr><tr><td>FPGM</td><td>75.59 (0.56)</td><td>15.9M (37%)</td><td>2.36B (42%)</td><td></td></tr><tr><td>SOSP (ours)</td><td>75.85 (0.30)</td><td>15.4M (40%)</td><td>2.44B (27%)</td><td>1.97B (49%)</td></tr><tr><td>HRank</td><td>71.98 (4.17)</td><td>13.8M (46%)</td><td>1.55B (62%)</td><td></td></tr><tr><td>CCP</td><td>75.21 (0.94)</td><td></td><td></td><td>1.77B (54%)</td></tr><tr><td>SOSP*(ours)</td><td>75.21 (0.94)</td><td>13.0M (49%)</td><td>2.13B (45%)</td><td>1.68B (56%)</td></tr><tr><td>SOSP (ours)</td><td>74.39 (1.76)</td><td>11.8M (54%)</td><td>1.89B (51%)</td><td>1.38B (64%)</td></tr><tr><td>SOSP*(ours)</td><td>73.38 (2.77)</td><td>9.9M (61%)</td><td>1.58B (59%)</td><td>1.10B (72%)</td></tr></table>
+
+# 3.2 Scalability and application to large-scale datasets
+
+Before going to large datasets, we compare the scalability of our methods SOSP-I and SOSP-H. As the preceding section shows, both methods perform basically on par with each other in terms of accuracy. This confirms that SOSP-H is not degraded by the approximations leading to the efficient Hessian-vector product, or is helped by use of the exact Hessian. In terms of efficiency, however, SOSP-H shows clear advantages compared to SOSP-I, for which the algorithm to select the structures to be pruned scales with ${ \cal O } ( \bar { \cal S } ^ { 3 } )$ (see Sec. 2.3) potentially dominating the overall runtime for large-scale networks. Measurements of the actual runtimes show that already for medium-sized networks SOSP-H is more efficient than SOSP-I (Fig. 2). Since SOSP-I becomes impractical for large-scale networks, for the ImageNet dataset we will only evaluate SOSP-H and refer to it as SOSP.
+
+211 On ImageNet, we compare our results to literature for ResNet-18 and ResNet-50, see Tab. 2. Because   
+212 SOSP assesses the sensitivity of each structure independently of the contributed MACs, it has a   
+213 bias towards pruning small-scale structures. This tendency is strongest for ResNet-50, due to its   
+214 $1 \times 1$ -convolutions. Since these $1 \times 1$ -convolutions tend to contribute disproportionately little to the   
+215 overall number of MACs, we devised a scaled variant of SOSP, which divides the saliency of every   
+216 structure by the kernel size (e.g. 1, 3 or 7). Compared to the vanilla SOSP, the scaled variant of SOSP   
+217 is able to remove larger percentages of MACs with similar drops in accuracy (see Tab. 2).   
+18 For both networks SOSP outperforms HRank and FPGM, especially when considering the main   
+19 objective of SOSP, which is to reduce the number of parameters or structures. Since CCP uses a   
+20 different way of calculating the MACs, which leads to consistently higher pruning ratios, we added   
+an alternative MAC count to enable a fair comparison (for details, see App. D). Since HRank and   
+22 FPGM do not mention their MAC counting convention, we assume they use the same convention   
+23 as we do. Taking this into account, our scaled SOSP variant is able to prune more MACs than CCP,   
+4 while having the same final accuracy.
+
+![](images/8fb16683ecd07c84d01e7d126b43a3a46dffafe4c8863c75d02039274161673b.jpg)  
+Figure 3: Comparison between pruning after training and at initialization on Cifar10. Both pruning schemes, train-pruning (a) and init-pruning (b), train the network for the same overall number of epochs, but generate and apply the pruning masks at different point in times. The average and standard deviation of the test accuracy across 3 trials is plotted against the number of model parameters for ResNet-56 (top row; c) and VGG (bottom row; f). For a single trial, in which overall $5 0 \%$ of the structures are pruned, we visualize the pruning masks of train-pruning and init-pruning by showing the layer-wise pruning ratios in (d, g) and (e, h), respectively.
+
+# 3.3 Pruning at Initialization
+
+Traditionally, pruning methods are applied to pretrained networks, as also done in the previous sections, but recently there has been growing attention on pruning at initialization following the works of Lee et al. (2018) and Frankle & Carbin (2018). Since SOSP employs the absolute value of the sensitivities, it can also be applied to a randomly initialized network without any modifications. Thus, SOSP can also be seen as an efficient second-order generalization of SNIP (Lee et al., 2018; van Amersfoort et al., 2020). While EigenDamage can in principle be modified and applied to a randomly initialized network, NN Slimming can not be applied at initialization.
+
+Usually pruning at initialization leads to worse accuracies than pruning after training (Liu et al., 2018). However, pruning an already trained network is often followed by fine-tuning effectively training the network twice (Fig. 3a). For comparability with pruning at initialization, we unify the overall training schedule between these two settings and consequently apply two training cycles after pruning the randomly initialized network (Fig. 3b; for further discussion, see App. A.5).
+
+We observe that applying SOSP at initialization performs almost equally well than applying SOSP after training (see ResNet-56 and VGG in Fig. 3c and f, respectively). In conclusion, applying SOSP at initialization can significantly reduce the time and resources required for network training with no or only minor degradation in accuracy.
+
+# 3.4 Identifying & Removing Architectural Bottlenecks
+
+43 Even though the previous section highlighted that applying SOSP after training and at initialization   
+244 results in comparable accuracies, the pruning masks differ between these two scenarios (compare Fig.   
+245 3d and g to e and h, resp.). Despite this difference a common feature of all masks is that some layers   
+246 are barely pruned or not pruned at all while others are pruned by up to $8 0 \%$ . This could indicate   
+247 towards architectural bottlenecks. We consider a layer an architectural bottleneck if the respective   
+248 layer has a considerably lower pruning ratio compared to the other layers. The low pruning ratio of   
+249 bottleneck layers indicates that the substructures (e.g. filters) have a high sensitivity. Thus, widening   
+250 these layers could improve the overall performance and allow for even smaller models with higher   
+251 accuracies.   
+252 To utilize this insight we device a procedure that we call expand-pruning. The idea is to first calculate   
+253 the pruning ratios of a trained network and then to identify architectural bottlenecks, i.e. the layers   
+254 with the lowest pruning ratios. Next, we widen these layers by a factor of two, which has been   
+255 empirically shown to work well. Finally, we randomly initialize, train, prune, and fine-tune the   
+256 expanded network (for a schematic, see Fig. 4a). As a naive baseline that we call the widen-pruning   
+257 procedure, we widen all layers in the network with a constant factor instead of widening specific   
+258 layers. We choose the constant factor such that the overall number of parameters matches that of the   
+259 expand-prune procedure (see width multiplier in Fig. 4).   
+260 We evaluate the expand-pruning procedure for ResNet-56 and VGG on Cifar10, for which we expand   
+261 the least pruned of the three main building blocks and the five least pruned layers, respectively (e.g.,   
+262 see width multipliers in Fig. 4c and f selected on the basis of the pruning masks shown in Fig. 3d and   
+263 g, resp.). Note that for ResNet-56 a more fine-grained removal of bottlenecks, e.g. on layer level,   
+264 is not possible without changing the overall ResNet architecture. In summary, a selective removal   
+265 of bottlenecks results in smaller network models with higher accuracy than pruning the vanilla   
+266 network or unselectively increasing the network size (compare expand-pruning to train-pruning and   
+267 widen-pruning in Fig. 4b and e). While in principle any global pruning method could be used for   
+268 the expand-pruning procedure, SOSP is especially suited since it does not require to modify the   
+269 network architecture like EigenDamage and can also be applied at initialization unlike NN Slimming,   
+270 allowing for a similar expand scheme directly at initialization (see App. A.6).
+
+![](images/758a802e57d71e1fa13757cac17fb49c8b78c4a8458b376f4ee85ee474fcfc1d.jpg)  
+Figure 4: We remove architectural bottlenecks found by SOSP using the expand-pruning scheme (a) on Cifar10. The width of blocks and layers with low pruning ratios in the train-pruning scheme (Fig. 3d and g) are expanded by a width multiplier of 2 (c, f). As a baseline, we uniformly expand all layers in the network by a factor 1.1 (d, g). The layer-wise pruning ratios of the enlarged network models are shown as bar plots in (c, d, f, g). The average and standard deviation of the test accuracy across 3 trials are shown over the number of model parameters (b, e). Note that the full ResNet-56 and VGG models have $0 . 8 6 \cdot 1 0 ^ { 6 }$ and $2 0 \cdot 1 0 ^ { 6 }$ parameters, respectively.
+
+# 271 4 Discussion
+
+In this work we have demonstrated the effectiveness and scalability of our second-order structured pruning algorithms (SOSP). While both algorithms perform similarly well, SOSP-H is more easily scalable to large scale networks and datasets. We highlighted two major features of our method. Firstly, SOSP can be applied at initialization with only minor degradation in accuracy, which drastically reduces the required time and resources for training. Secondly, we showed that the pruning masks
+
+77 found by SOSP can be used to systematically detect and remove architectural bottlenecks, further   
+278 improving the performance of pruned networks.   
+279 Compared to other global pruning methods, SOSP captures correlations between structures by a sim  
+280 ple, effective and scalable algorithm that neither requires to modify the training nor the architecture of   
+281 the to be pruned network model and achieves comparable or better accuracies on benchmark datasets.   
+282 The C-OBD algorithm (Wang et al., 2019a) is a structured generalization of the original unstructured   
+283 OBD algorithm (LeCun et al., 1990). In contrast to OBD, C-OBD accounts for correlations within   
+284 each structure, but does not capture correlations between different structures within and across layers.   
+285 We show that considering these global correlations consistently improve the performance, especially   
+286 for large pruning ratios (Tab. 1). This observation is further confirmed by an ablation study in which   
+287 we neglect all cross-structure correlations significantly decreasing the performance under otherwise   
+288 identical experimental settings (App. A.2). The objective of EigenDamage (Wang et al., 2019a) to   
+289 include second order correlations is similar to ours, but the approaches are significantly different.   
+290 EigenDamage uses the Fisher-approximation, which is similar to the Gauss-Newton approximation   
+291 used for SOSP-I, and then, in addition to further approximations, apply low rank approximations   
+292 that require the substitution of each layer by a bottleneck-block structure. Our SOSP method is   
+293 simpler, easier to implement and does not require to modify the network architecture, but nevertheless   
+294 performs on par with EigenDamage. The approach of NN Slimming (Liu et al., 2017) is more   
+295 heuristic than SOSP and is easy to implement. However, networks need to be pretrained with $L _ { 1 }$   
+296 regularization on the batch-normalization parameters, otherwise the performance is severly harmed   
+297 (Tab. 1 and 3). SOSP does not require any modifications to the network training and can be applied   
+298 to any pretrained network. A recent variant of NN Slimming was developed by Zhuang et al. (2020)   
+299 who optimize their hyperparameters to reduce the number of MACs. Using the number MACs as an   
+300 objective for SOSP is left for future studies.   
+301 In addition to the above comparison to other global pruning methods, we also compared our methods   
+302 to simpler local pruning methods that keep the pruning ratios constant for each layer and, consequently,   
+303 scale well to large-scale datasets. The pruning method closest to our SOSP-I method is the one by   
+304 Peng et al. (2019). While both works consider second-order correlations between structures, theirs is   
+305 based on a pruning objective different from our absolute sensitivites in $\lambda _ { 2 } ^ { I }$ and considers only intra  
+306 layer correlations. Furthermore, they employ an auxiliary classifier with a hyperparameter, yielding   
+307 accuracy improvements that are difficult to disentangle from the effect of second-order pruning. Going   
+308 beyond a constant pruning ratio for each layer Su et al. (2020) discovered, for ResNets, that pruning   
+309 at initialization seems to preferentially prune initial layers and thus proposed a pruning scheme based   
+310 on a “keep-ratio” per layer which increases with the depth of the network. Our experiments confirm   
+311 some of the findings of Su et al. (2020), but we also show that the specific network architectures found   
+312 by pruning can drastically vary between different networks and especially between initialization and   
+313 after training (histograms in Fig. 3). While all local pruning methods specify pruning ratios for each   
+314 layer, our method performs automatic selection across layers (histograms in Fig. 3).   
+315 This automatic selection allows us to identify and remove architectural bottlenecks. However, our   
+316 global pruning method has a bias towards pruning small structures, absent from local pruning methods,   
+317 as the size of structures is usually identical within layers. We propose a simple solution by scaling   
+318 each structure by the inverse of the kernel size which helps to remove some of the bias. Alternatively,   
+319 to better reflect the computational costs in real-world applications, each structure could also be   
+320 normalized by the number of its required MACs (like done by van Amersfoort et al., 2020).   
+321 Recently, unstructured (Lee et al., 2018; Wang et al., 2019b; Tanaka et al., 2020) and structured   
+322 (van Amersfoort et al., 2020; Hayou et al., 2021) pruning schemes that are applicable to networks   
+323 at initialization were proposed. While these methods fail to achieve similar accuracies compared to   
+324 pruning after training, our SOSP method in the init-pruning setting achieves accuracies comparable   
+325 to pruning after training.
+
+In accordance with Elsken et al. (2019), our results suggest that pruning can be used to optimize the architectural hyperparameters of established networks (Liu et al., 2018) or super-graphs (Noy et al., 2020). Instead of formulating this optimization as a pruning process, we envision our second-order sensitivity analysis to be a valuable tool to identify and remove bottlenecks to find good neural architectures more quickly. For example, whenever a building block of the neural network cannot be compressed, this building block may be considered a bottleneck of the architecture and could be inflated to improve the overall trade-off between accuracy and computational cost.
+
+#
+
+References   
+334 Blalock, D., Ortiz, J. J. G., Frankle, J., and Guttag, J. What is the state of neural network pruning? arXiv preprint arXiv:2003.03033, 2020.   
+336 Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.   
+339 Elsken, T., Metzen, J. H., and Hutter, F. Neural architecture search: A survey. Journal of Machine Learning Research, 20(55):1–21, 2019. Fletcher, R. Practical methods of optimization. John Wiley & Sons, 2013. Frankle, J. and Carbin, M. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2018. Han, S., Pool, J., Tran, J., and Dally, W. Learning both weights and connections for efficient neural network. Advances in neural information processing systems, 28:1135–1143, 2015. Hassibi, B., Stork, D. G., and Wolff, G. J. Optimal brain surgeon and general network pruning. In IEEE international conference on neural networks, pp. 293–299. IEEE, 1993. Hayou, S., Ton, J.-F., Doucet, A., and Teh, Y. W. Robust pruning at initialization. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id= vXj_ucZQ4hA.   
+351 He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.   
+353 He, Y., Zhang, X., and Sun, J. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1389–1397, 2017. He, Y., Liu, P., Wang, Z., Hu, Z., and Yang, Y. Filter pruning via geometric median for deep convolutional neural networks acceleration. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4340–4349, 2019. Huang, G., Liu, Z., Van Der Maaten, L., and Weinberger, K. Q. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.   
+361 Jacot, A., Gabriel, F., and Hongler, C. Neural tangent kernel: convergence and generalization in neural networks. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pp. 8580–8589, 2018.   
+Krizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   
+365 LeCun, Y., Denker, J. S., and Solla, S. A. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.   
+367 Lee, N., Ajanthan, T., and Torr, P. Snip: Single-shot network pruning based on connection sensitivity. In International Conference on Learning Representations, 2018. Lin, M., Ji, R., Wang, Y., Zhang, Y., Zhang, B., Tian, Y., and Shao, L. Hrank: Filter pruning using high-rank feature map. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1529–1538, 2020.   
+372 Lin, S., Ji, R., Yan, C., Zhang, B., Cao, L., Ye, Q., Huang, F., and Doermann, D. Towards optimal structured cnn pruning via generative adversarial learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2790–2799, 2019. Liu, Z., Li, J., Shen, Z., Huang, G., Yan, S., and Zhang, C. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), Oct 2017.   
+Liu, Z., Sun, M., Zhou, T., Huang, G., and Darrell, T. Rethinking the value of network pruning. In International Conference on Learning Representations, 2018.   
+Mingjie, S. and Zhuang, L. Network slimming. https://github.com/Eric-mingjie/ network-slimming, 2018.   
+Noy, A., Nayman, N., Ridnik, T., Zamir, N., Doveh, S., Friedman, I., Giryes, R., and Zelnik, L. ASAP: Architecture search, anneal and prune. In Chiappa, S. and Calandra, R. (eds.), Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pp. 493–503, 2020.   
+Peng, H., Wu, J., Chen, S., and Huang, J. Collaborative channel pruning for deep networks. In International Conference on Machine Learning, pp. 5113–5122. PMLR, 2019.   
+Reed, R. Pruning algorithms-a survey. IEEE transactions on Neural Networks, 4(5):740–747, 1993.   
+Simonyan, K. and Zisserman, A. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   
+Su, J., Chen, Y., Cai, T., Wu, T., Gao, R., Wang, L., and Lee, J. D. Sanity-checking pruning methods: Random tickets can win the jackpot. In Advances in Neural Information Processing Systems, 2020.   
+Tanaka, H., Kunin, D., Yamins, D. L., and Ganguli, S. Pruning neural networks without any data by iteratively conserving synaptic flow. Advances in Neural Information Processing Systems, 33, 2020.   
+Tang, Y., Wang, Y., Xu, Y., Tao, D., Xu, C., Xu, C., and Xu, C. Scop: Scientific control for reliable neural network pruning. Advances in Neural Information Processing Systems, 2020.   
+van Amersfoort, J., Alizadeh, M., Farquhar, S., Lane, N., and Gal, Y. Single shot structured pruning before training. arXiv preprint arXiv:2007.00389, 2020.   
+Wang, C., Grosse, R., Fidler, S., and Zhang, G. Eigendamage: Structured pruning in the kroneckerfactored eigenbasis. In International Conference on Machine Learning, pp. 6566–6575, 2019a.   
+Wang, C., Zhang, G., and Grosse, R. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2019b.   
+Zhao, C., Ni, B., Zhang, J., Zhao, Q., Zhang, W., and Tian, Q. Variational convolutional neural network pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2780–2789, 2019.   
+Zhuang, T., Zhang, Z., Huang, Y., Zeng, X., Shuang, K., and Li, X. Neuron-level structured pruning using polarization regularizer. Advances in Neural Information Processing Systems, 33, 2020.
+
+# Checklist
+
+1. For all authors...
+
+(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   
+(b) Did you describe the limitations of your work? [Yes]   
+(c) Did you discuss any potential negative societal impacts of your work? [N/A]   
+(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes]
+
+2. If you are including theoretical results...
+
+(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes]
+
+3. If you ran experiments...
+
+(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes]
+
+(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   
+(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   
+(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes]
+
+4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
+
+(a) If your work uses existing assets, did you cite the creators? [Yes]   
+(b) Did you mention the license of the assets? [Yes]   
+(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   
+(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   
+(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A]
+
+5. If you used crowdsourcing or conducted research with human subjects...
+
+(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   
+(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   
+(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A]

parse/train/sUgpxb9QD/sUgpxb9QD_content_list.json

@@ -0,0 +1,1151 @@
+[
+    {
+        "type": "text",
+        "text": "SOSP: Efficiently Capturing Global Correlations by Second-Order Structured Pruning ",
+        "text_level": 1,
+        "bbox": [
+            183,
+            122,
+            815,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            580,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Pruning neural networks reduces inference time and memory cost, as well as accelerates training when done at initialization. On standard hardware, these benefits will be especially prominent if coarse-grained structures, like feature maps, are pruned. We devise global saliency-based methods for second-order structured pruning (SOSP) which include correlations among structures, whereas highest efficiency is achieved by saliency approximations using fast Hessian-vector products. We achieve state-of-the-art results for various object classification benchmarks, especially for large pruning rates highly relevant for resource-constrained applications. We showcase that our approach scales to large-scale vision tasks, even though it captures correlations across all layers of the network. Further, we highlight two outstanding features of our methods. First, to reduce training costs our pruning objectives can also be applied at initialization with no or only minor degradation in accuracy compared to pruning after pretraining. Second, our structured pruning methods allow to reveal architectural bottlenecks, which we remove to further increase the accuracy of the networks. ",
+        "bbox": [
+            148,
+            351,
+            766,
+            559
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "16 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            588,
+            312,
+            606
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "17 Deep neural networks have consistently grown in size over the last years with increasing performance.   \n18 However, this increase in size leads to slower inference, higher computational requirements and   \n19 higher cost. To reduce the size of the networks without affecting their performance, a large number   \n20 of pruning algorithms have been proposed (e.g., LeCun et al., 1990; Hassibi et al., 1993; Reed, 1993;   \n21 Han et al., 2015; Blalock et al., 2020). Pruning can either be unstructured, i.e. removing individual   \n22 weights, or structured, i.e. removing entire substructures like nodes or channels. Single-shot pruning   \n23 methods, as investigated in this work, usually consist of three steps: 1) training, 2) pruning, 3) another   \n24 training step often referred to as fine-tuning.   \n25 Unstructured pruning can significantly reduce the number of parameters of a neural network with   \n26 only little loss in the accuracy, but the resulting networks often show only a marginal improvement in   \n27 training and inference time, unless specialized hardware is used (He et al., 2017). In contrast, struc  \n28 tured pruning can directly reduce inference time and even training time when applied at initialization   \n29 (Lee et al., 2018). To exploit these advantages, in this work, we focus on structured pruning.   \n30 Most sensitivity-based pruning methods such as OBD (e.g., LeCun et al., 1990) or C-OBD (Wang   \n31 et al., 2019a) evaluate the effect of removing a single weight or structure on the loss of the neural   \n32 network, while neglecting possible correlations between different structures and within the structures   \n33 themselves. This can significantly harm the estimation of the sensitivities. We take these correlations   \n34 into account by applying efficient second-order estimations that not only consider the diagonal terms   \n35 of the Hessian, but also all off-diagonal terms.   \n36 Global pruning removes structure by structure from all available structures of a network until a   \n37 predefined percentage of pruned structures is reached. Recent examples for global structured pruning   \n38 methods are NN Slimming (Liu et al., 2017), C-OBD and EigenGamage (Wang et al., 2019a). Local   \n39 pruning, on the other hand, first subdivides all global structures into subsets (e.g. layers) and removes   \n40 a percentage of structures of each subset. Recent examples for local pruning methods are HRank   \n41 (Lin et al., 2019), CCP (Peng et al., 2019), FPGM (He et al., 2019) and Variational Pruning (Zhao   \n42 et al., 2019). Most local pruning schemes use a predefined layer-wise pruning ratio, which fixes the   \n43 percentage of structures removed per layer. While this approach prevents the layers from collapsing,   \n44 it also reduces some of the degrees of freedom, since some layers may be less important than others.   \n45 Our main goal in this work is to devise a simple and efficient second-order pruning method, which   \n46 considers all global correlations for structured sensitivity pruning. In addition, we want to highlight   \n47 the benefits that such methods may have over other structured global and local pruning schemes. ",
+        "bbox": [
+            147,
+            622,
+            825,
+            733
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            739,
+            825,
+            808
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            815,
+            825,
+            898
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            90,
+            825,
+            217
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            222,
+            826,
+            265
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "48 Our contributions are as follows: ",
+        "bbox": [
+            150,
+            271,
+            390,
+            285
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "• We introduce two novel saliency-based methods for second-order structured pruning (SOSP), which consider all correlations across structures and layers. We benchmark our SOSP methods against a variety of state-of-the-art pruning methods on several networks and datasets and achieve comparable or better results at low computational costs. • We show that our pruning methods can also be applied at initialization almost matching the performance of pruning after training and significantly reducing the cost of network training. • We exploit the structure of the pruning masks found by our SOSP methods to remove architectural bottlenecks, which further improves the performance of the pruned networks. In this work, we consider layers with disproportionally low pruning ratios architectural bottlenecks. ",
+        "bbox": [
+            217,
+            296,
+            825,
+            449
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "PyTorch code implementing our method is attached in the Supplementary Material and we will publish the code upon acceptance of this manuscript. ",
+        "bbox": [
+            161,
+            460,
+            823,
+            489
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "61 2 SOSP: Second-order structured pruning ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            508,
+            545,
+            526
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "62 A neural network (NN) maps an input $x \\in \\mathbb { R } ^ { d }$ to an output $f _ { \\theta } ( x ) \\in \\mathbb { R } ^ { D }$ , where $\\theta \\in \\mathbb { R } ^ { P }$ are its   \n63 64 $P$ parameters. NN training proceeds, after random intch stochastic gradient descent on the empirical loss $\\begin{array} { r } { \\mathcal { L } ( \\boldsymbol { \\theta } ) : = \\frac { 1 } { N } \\sum _ { n = 1 } ^ { N } \\ell \\left( f _ { \\boldsymbol { \\theta } } ( x _ { n } ) , y _ { n } \\right) } \\end{array}$ $\\theta = \\theta _ { 0 }$ s, by mini-, given the   \n65 training dataset . In the classification case, $y \\in \\{ 1 , \\ldots , D \\}$ is a discrete   \n66 ground-truth label and $\\ell ( f _ { \\theta } ( x ) , y ) : = - \\log \\sigma \\left( f _ { \\theta } ( x ) \\right) _ { y }$ the cross-entropy loss, with $\\overset { \\prime } { \\sigma } : \\mathbb { R } ^ { D }  \\mathbb { R } ^ { D }$ ",
+        "bbox": [
+            147,
+            540,
+            825,
+            617
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "the softmax-function. For regression, 67 $\\boldsymbol { y } \\in \\mathbb { R } ^ { D }$ and $\\begin{array} { r } { \\ell ( f _ { \\theta } ( x ) , y ) = \\frac { 1 } { 2 } \\left\\| f _ { \\theta } ( x ) - y \\right\\| ^ { 2 } } \\end{array}$ is the squared loss. ",
+        "bbox": [
+            153,
+            617,
+            825,
+            633
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "68 Structured pruning aims to remove weights or rather entire structures from a $\\Nu { \\cal f } _ { \\theta }$ with parameters   \n69 $\\theta$ . A structure can be a filter (channel) in a convolutional layer, a neuron in a fully-connected layer, or   \n70 an entire layer in a parallel architecture. We assume the NN in question has been segmented into   \n71 $S$ structures $s = 1 , \\ldots , S$ , which can potentially be pruned. We define the notation $\\boldsymbol { \\theta _ { s } } ^ { \\mathbf { \\bar { \\theta } } } \\in \\mathbb { R } ^ { P }$ as the   \n72 vector whose only nonzero components are those weights from $\\theta$ that belong to structure $s$ .1 Then, a   \n73 pruning mask is a set $M = \\{ s _ { 1 } , \\ldots , s _ { m } \\}$ of structures. Applying a mask $M$ to a NN $f _ { \\theta }$ means to   \n74 consider the NN with parameter vector $\\begin{array} { r } { \\dot { \\theta _ { \\setminus M } } : = \\theta - \\sum _ { s \\in M } \\bar { \\theta } _ { s } } \\end{array}$ .2   \n75 We now develop our pruning methods that incorporate global correlations into their saliency as  \n76 sessment by efficiently including the second-order loss terms. The first method (SOSP-I) admits a   \n77 direct interpretation in terms of individual loss sensitivities, while the second (SOSP-H) remains very   \n78 efficient for the largest networks due to its Hessian-vector product approximation.   \n79 The basic idea behind both our pruning methods is to select the pruning mask $M$ so as to (approxi  \n80 mately) minimize the joint effect on the network loss ",
+        "bbox": [
+            147,
+            638,
+            825,
+            738
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            742,
+            825,
+            797
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            804,
+            825,
+            832
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2caf1e62af79f63ef3162af55bdeb9b878cb5286bbc73bc10e804e97495b29ac.jpg",
+        "text": "$$\n\\lambda ( M ) : = \\left| \\mathcal { L } ( \\boldsymbol { \\theta } ) - \\mathcal { L } ( \\boldsymbol { \\theta } _ { \\setminus M } ) \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            405,
+            839,
+            591,
+            859
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "81 of removing all structures in $M$ , subject to a constraint on the overall pruning ratio. To circumvent   \n82 this exponentially large search space, we approximate the loss up to second order, so that ",
+        "bbox": [
+            147,
+            90,
+            825,
+            121
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/ab8158d81d23deb50ee177cfcd8abb5c2ceac0565709429364302ae33bd341a0.jpg",
+        "text": "$$\n\\lambda _ { 2 } ( M ) = \\left| \\sum _ { s \\in M } \\theta _ { s } ^ { T } \\frac { d \\mathcal { L } ( \\theta ) } { d \\theta } - \\frac { 1 } { 2 } \\sum _ { s , s ^ { \\prime } \\in M } \\theta _ { s } ^ { T } \\frac { d ^ { 2 } \\mathcal { L } ( \\theta ) } { d \\theta d \\theta ^ { T } } \\theta _ { s ^ { \\prime } } \\right|\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            122,
+            673,
+            172
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "83 collapses to single-structure contributions plus pairwise correlations; note that the latter include interactions among the weights within a single 84 $s = s ^ { \\prime }$ , which can be sizeable for large structures. ",
+        "bbox": [
+            155,
+            175,
+            825,
+            204
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "85 The first-order terms $\\lambda _ { 1 } ( s ) : = \\theta _ { s } \\cdot d \\mathcal { L } ( \\theta ) / d \\theta \\in \\mathbb { R } ^ { P }$ in (1) are efficient to evaluate by computing the   \n86 gradient $d { \\mathcal { L } } ( \\theta ) / d \\theta \\in \\mathbb { R } ^ { P }$ once and then a (sparse) dot product for every $s$ . In contrast to these first  \n87 order terms, the network Hessian $H ( \\theta ) : = \\bar { d ^ { 2 } } \\mathcal { L } ( \\theta ) / d \\theta ^ { \\hat { 2 } } \\in \\mathbb { R } ^ { P \\times P }$ in (1) is prohibitively expensive to   \n88 compute or store in full. We therefore propose two different schemes to efficiently overcome this   \n89 obstacle. Each scheme entails its own way to select the pruning mask. We name the full methods   \n90 SOSP-I (individual sensitivities) and SOSP-H (Hessian-vector product). ",
+        "bbox": [
+            147,
+            208,
+            826,
+            294
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "91 2.1 SOSP-I: Saliency from individual sensitivities ",
+        "text_level": 1,
+        "bbox": [
+            147,
+            308,
+            529,
+            324
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "92 SOSP-I approximates each individual term $\\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } }$ in (1) efficiently, as we will show in Eq. (6).   \n93 We can therefore consider a modification of Eq. (1) in which the sensitivity is judged by considering   \n94 all single and pairwise sensitivities individually: ",
+        "bbox": [
+            145,
+            333,
+            826,
+            377
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/7f034c478133fc08b0cad8320e63885aa4b26c8d2534c308d95a5708b0b3947c.jpg",
+        "text": "$$\n\\lambda _ { 2 } ^ { I } ( M ) = \\sum _ { s \\in M } \\left| \\theta _ { s } ^ { T } \\frac { d \\mathcal { L } ( \\theta ) } { d \\theta } \\right| + \\frac { 1 } { 2 } \\sum _ { s , s ^ { \\prime } \\in M } \\left| \\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } } \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            328,
+            378,
+            669,
+            420
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "95 To avoid cancellations between signed contributions, we take absolute values because this measures   \n96 the strengths of the individual sensitivities $\\lambda _ { 1 } ( s )$ and pairwise correlations $\\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } }$ . While   \n97 objectives other than $\\lambda _ { 2 } ^ { I }$ are equally possible in the method, including $\\lambda _ { 2 }$ and modifications with the   \n98 absolute value not pulled in all the way, we found empirically that $\\bar { \\lambda _ { 2 } ^ { I } }$ performs best overall.   \n99 Then, SOSP-I iteratively selects the structures to prune, based on the objective (2): Starting from   \n100 an empty pruning mask $M = \\{ \\}$ , we iteratively add to $M$ the structure $s \\notin M$ that minimizes the   \n101 overall sensitivity $\\lambda _ { 2 } ^ { I } ( M \\cup \\{ s \\} )$ . In practice, the algorithm pre-computes the matrix $Q \\in \\mathbb { R } ^ { S \\times S }$ , ",
+        "bbox": [
+            145,
+            422,
+            825,
+            479
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            484,
+            825,
+            529
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/9d667da2ecd43b5d7e8dc31d01bbe67828e7902e7b91062714c32f6ec2878c88.jpg",
+        "text": "$$\nQ _ { s , s ^ { \\prime } } : = \\frac { 1 } { 2 } \\left| \\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } } \\right| + \\left| \\theta _ { s } ^ { T } \\frac { d \\mathcal { L } ( \\theta ) } { d \\theta } \\right| \\cdot \\delta _ { s = s ^ { \\prime } } ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            531,
+            651,
+            565
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "102 and selects at each iteration a structure $s \\notin M$ to prune by ",
+        "bbox": [
+            142,
+            569,
+            555,
+            584
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b602ea31151d31256e99583f0468537b8314b1004bc5e9008f1836a0212843a5.jpg",
+        "text": "$$\n\\underset { s \\notin { \\cal M } } { \\arg \\operatorname* { m i n } } \\lambda _ { 2 } ^ { I } ( { \\cal M } \\cup s ) - \\lambda _ { 2 } ^ { I } ( { \\cal M } ) = \\underset { s \\notin { \\cal M } } { \\arg \\operatorname* { m i n } } \\left( Q _ { s , s } + 2 \\sum _ { s ^ { \\prime } \\in { \\cal M } } Q _ { s , s ^ { \\prime } } \\right) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            282,
+            587,
+            715,
+            622
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "103 terminating at the desired pruning ratio. ",
+        "bbox": [
+            147,
+            626,
+            434,
+            641
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "104 105 $\\begin{array} { r } { \\frac { 1 } { N } \\sum _ { n } \\nabla _ { \\theta } ^ { 2 } \\ell ( f _ { \\theta } \\dot { ( x _ { n } ) } , y _ { n } ) } \\end{array}$ te the Hessian terms  those terms that involv $\\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } }$ efficiently, we omit from sive second-order derivatives $\\nabla _ { { \\boldsymbol { \\theta } } } ^ { 2 } f _ { \\boldsymbol { \\theta } } ( { \\boldsymbol { x } } _ { n } )$ $\\begin{array} { r l } { H ( \\theta ) } & { { } = } \\end{array}$   \n106 of the NN outputs, while including second-order couplings due to . This is equivalent to approx  \n107 imating $\\begin{array} { r } { H ( \\theta ) \\ \\tilde { \\ } \\approx H ( f _ { \\theta } ^ { l i n } ) : = \\frac { 1 } { N } \\sum _ { n } \\nabla _ { \\theta } ^ { 2 } \\ell ( f _ { \\theta } ^ { l i n } ( x _ { n } ) , \\tilde { \\ y } _ { n } ) } \\end{array}$ for the linearized $f _ { \\theta ^ { \\prime } } ( x ) \\approx f _ { \\theta ^ { \\prime } } ^ { l i n } ( \\stackrel { . . . } { x } ) : =$   \n108 $f _ { \\theta } ( x ) + \\phi ( x ) \\cdot ( \\theta ^ { \\prime } - \\theta )$ with $\\phi ( { \\boldsymbol { x } } ) : = \\nabla _ { \\theta } f _ { \\theta } ( { \\boldsymbol { x } } ) \\in \\mathbb { R } ^ { D \\times P }$ , which is well motivated by the NTK limit   \n109 (Jacot et al., 2018) for large NNs at both initialization and after training. The terms in the sum become ",
+        "bbox": [
+            140,
+            645,
+            826,
+            733
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/280adf94d7b94c9e525b39b3ecd4965b65e8816cbb638a4a865f3f7dc45ced42.jpg",
+        "text": "$$\n\\nabla _ { \\boldsymbol { \\theta } } ^ { 2 } \\ell \\left( f _ { \\boldsymbol { \\theta } } ^ { l i n } ( x _ { n } ) , y _ { n } \\right) = \\boldsymbol { \\phi } ( x _ { n } ) ^ { T } R _ { n } \\boldsymbol { \\phi } ( x _ { n } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            362,
+            736,
+            633,
+            756
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "110 where $R _ { n } \\ \\in \\ \\mathbb { R } ^ { D \\times D }$ is diagonal for squared loss, and has an additional rank-1 contribution for   \n111 cross-entropy (see App. B). Similar Hessian approximations were employed before in NNs (Hassibi   \n112 et al., 1993; Wang et al., 2019a; Peng et al., 2019) and also in the Gauss-Newton optimization method   \n113 (Fletcher, 2013). Our final approximation is to use a random subsample of $N ^ { \\prime } < N$ data points: ",
+        "bbox": [
+            142,
+            760,
+            825,
+            816
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "equation",
+        "img_path": "images/72560a22b30245b87fbc488d8e010d030480b8643a59896914c0df51f8334373.jpg",
+        "text": "$$\n\\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } } \\approx \\frac { 1 } { N ^ { \\prime } } \\sum _ { n = 1 } ^ { N ^ { \\prime } } \\left( \\phi ( x _ { n } ) \\theta _ { s } \\right) ^ { T } R _ { n } \\left( \\phi ( x _ { n } ) \\theta _ { s ^ { \\prime } } \\right) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            330,
+            820,
+            666,
+            864
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "114 In practice, one pre-computes all (sparse) products $\\phi ( x _ { n } ) \\theta _ { s } \\in \\mathbb { R } ^ { D }$ starting from the efficient gradient   \n115 $\\phi ( x _ { n } )$ , before aggregating a batch onto the terms $\\theta _ { s } ^ { T } H ( \\theta ) \\theta _ { s ^ { \\prime } }$ . Eq. (6) also has an interpretation as   \n116 output correlations between certain network modifications, without using derivatives (App. C).   \n118 SOSP-H treats the second-order terms in (1) in a way that is motivated by the limit of large pruning   \n119 ratios: At high pruning ratios, the sum $\\sum _ { s ^ { \\prime } \\in M } \\theta _ { s ^ { \\prime } }$ in (1) can be approximated by $\\begin{array} { r } { \\sum _ { s ^ { \\prime } = 1 } ^ { \\bar { S } } \\theta _ { s ^ { \\prime } } = : } \\end{array}$   \n120 $\\theta _ { s t r u c }$ (this equals if every NN weight belongs to some structure $s$ ). The second-order term   \n121 $\\begin{array} { r } { \\sum _ { s , s ^ { \\prime } \\in M } \\theta _ { s } ^ { T } \\dot { H ( \\theta ) } \\theta _ { s ^ { \\prime } } \\approx \\left( \\sum _ { s \\in M } \\theta _ { s } ^ { T } \\right) \\left( \\check { H } ( \\theta ) \\theta _ { s t r u c } \\right) } \\end{array}$ \u0001 thus becomes tractable since the Hessian-vector   \n122 product $H ( \\theta ) \\theta _ { s t r u c }$ is efficiently computable by a variant of the backpropagation algorithm. To   \n123 account for each structure $s$ and for the first- and second-order contributions separately, as above, we   \n124 place absolute value signes in (1) so as to arrive at the final objective $\\begin{array} { r } { \\lambda _ { 2 } ^ { H } ( M ) \\overset { \\cdot } { : = } \\sum _ { s \\in M } \\lambda _ { 2 } ^ { H } ( s ) } \\end{array}$ with ",
+        "bbox": [
+            140,
+            868,
+            825,
+            912
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            116,
+            826,
+            219
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/cbbc370d8b663f4a4fcfdf15d51405128076e1828ee02b0ebaac3d0b7074aeaa.jpg",
+        "text": "$$\n\\lambda _ { 2 } ^ { H } ( s ) : = \\left| \\theta _ { s } ^ { T } \\frac { d \\mathcal { L } ( \\theta ) } { d \\theta } \\right| + \\frac { 1 } { 2 } \\left| \\theta _ { s } ^ { T } \\big ( H ( \\theta ) \\theta _ { s t r u c } \\big ) \\right| .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            344,
+            222,
+            651,
+            257
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "125 The last term measures the correlations between one structure $s$ and all other prunable structures,   \n126 although some of these may cancel unlike for SOSP-I. To minimize $\\lambda _ { 2 } ^ { H } ( M )$ , SOSP-H starts from an   \n127 empty pruning mask $M = \\{ \\}$ , and successively adds to $M$ a structure $s \\notin M$ with smallest $\\lambda _ { 2 } ^ { H } ( s )$ .   \n128 Unlike the Gauss-Newton approximation in SOSP-I, SOSP-H uses the exact Hessian $H ( \\theta )$ , but can   \n129 therefore not account for individual absolute $s { - } s ^ { \\prime }$ -correlations, see Eq. (7) vs. (2). Both methods   \n130 reduce to the same first-order pruning method when neglecting the second order (i.e. $H ( \\theta ) : = 0 \\rangle$ ). ",
+        "bbox": [
+            142,
+            258,
+            825,
+            301
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            305,
+            825,
+            349
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "2.3 Computational complexity ",
+        "text_level": 1,
+        "bbox": [
+            171,
+            363,
+            397,
+            378
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "132 We detail here the computational complexities of our methods (for the experimental evaluation see   \n133 Sec. 3.2). The approximation of $Q$ in (3) requires complexity $O \\left( N ^ { \\prime } D ( F + P ) \\right) = O ( N ^ { \\prime } D F )$ for   \n134 computing all $\\bar { \\phi ( \\boldsymbol { x } _ { n } ) } \\theta _ { s }$ , where $F \\geq P$ denotes the cost of one forward pass through the network   \n135 $F \\approx P$ for fully-connected NNs), plus $O ( N ^ { \\prime } D S ^ { 2 } )$ for the sum in (6). This is tractable for modern   \n136 NNs, while including the exact $H ( \\theta )$ would have complexity at least $O ( N ^ { \\prime } D S F )$ . Once $Q$ has been   \n137 computed, the selection procedure based on (4) has overall complexity ${ \\cal O } ( S ^ { 3 } )$ , which is feasible for   \n138 most modern convolutional NNs (Sec. 3.2). The total complexity of the SOSP-I method is thus ",
+        "bbox": [
+            140,
+            388,
+            825,
+            486
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/355190e72c986a8bace9c3645e27af4718e9e97ad096f3dcbb72ced8ee77f60c.jpg",
+        "text": "$$\nO ( N ^ { \\prime } D F ) + O ( N ^ { \\prime } D S ^ { 2 } ) + O ( S ^ { 3 } ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            379,
+            488,
+            619,
+            506
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "139 SOSP-H has computational complexity $O ( N ^ { \\prime } D F )$ to compute the sensitivities (7), which is com  \n140 parable to computing the sensitivities $Q$ in SOSP-I when the number of structures is low $( S ^ { 2 } \\lesssim F )$ .   \n141 Together with the sorting of the saliency values $\\lambda _ { 2 } ^ { H } ( s )$ , the overall complexity of SOSP-H is thus ",
+        "bbox": [
+            142,
+            513,
+            826,
+            558
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ff3079da0b303e188346e8db73c0ae3a172446d97471b1f0647b4fbfebbc75a.jpg",
+        "text": "$$\nO ( N ^ { \\prime } D F ) + O ( S \\log ( S ) ) .\n$$",
+        "text_format": "latex",
+        "bbox": [
+            406,
+            559,
+            588,
+            577
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "142 Due to its weak dependency on $S$ , in practice, SOSP-H efficiently scales to large modern networks   \n143 and may even be used for unstructured second-order pruning, where $S = P$ .   \n144 Both of our methods scale much better than naively including all off-diagonal Hessian terms, which   \n145 is intractable for modern NNs due to its $O ( N ^ { \\prime } D \\dot { S } F )$ scaling. Since SOSP-I builds on individual   \n146 absolute sensitivities and the established Gauss-Newton approximation, we use SOSP-I in the   \n147 following in particular to validate the more efficient SOSP-H method. ",
+        "bbox": [
+            145,
+            579,
+            825,
+            607
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            613,
+            825,
+            669
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "148 3 Results ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            688,
+            266,
+            704
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "149 To evaluate our methods, we train and prune VGGs (Simonyan & Zisserman, 2014), ResNets (He   \n150 et al., 2016), and DenseNets (Huang et al., 2017) on the Cifar10/100 (Krizhevsky et al., 2009) and   \n151 ImageNet (Deng et al., 2009) datasets. Stochastic gradient descent with an initial learning rate of 0.1,   \n152 a momentum of 0.9 and weight decay of $1 0 ^ { - 4 }$ is used to train these networks. For ResNet-32/56 and   \n153 VGG-Net on Cifar10/100, we use a batch size of 128, train for 200 epochs and reduce the learning rate   \n154 by a factor of 10 after 120 and 160 epochs. To fine-tune the network after pruning, we exactly repeat   \n155 this learning rate schedule. For DenseNet-40 on Cifar10/100, we train for 300 epochs and reduce   \n156 the learning rate after 150 and 225 epochs. For ResNets on ImageNet, we use a batch size of 256,   \n157 train for 128 epochs and use a cosine learning rate decay. For all networks, we prune feature maps   \n158 (i.e. channels) from all layers except the last fully-connected layer; for ResNets, we also exclude the   \n159 downsampling-path from pruning. We approximate the Hessians by a subsample of size $N ^ { \\prime } = 1 0 0 0$   \n160 (see Sec. 2.1). We report the best or average final test accuracy over 3 trials if not noted otherwise.   \n161 The experiments were run on an internal cluster with Nvidia Tesla V100 GPUs. Reproducing the   \n162 results presented in this paper would take about 60 days of GPU run-time. ",
+        "bbox": [
+            140,
+            717,
+            826,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "table",
+        "img_path": "images/8bc2eab2424773321ebf10560b9fdae4d2113c81a8f118678eda85d060cc6a3d.jpg",
+        "table_caption": [
+            "Table 1: Comparison of SOSP to other global pruning methods for high pruning ratios. The comparison for moderate pruning ratios is defered to the appendix (see App. A.1). We tuned our pruning ratios to similar values as reported by the referred methods. To ensure identical implementations of the network models in PyTorch, reference numbers are taken from Wang et al. (2019a) and (Mingjie & Zhuang, 2018). In accordance with all referred methods, we report the mean and standard deviation of the best accuracies observed during fine-tuning. For final accuracies after fine-tuning see App. A.3. \\* denotes the baseline model. Both SOSP methods perform either on par or outperform the competing global pruning methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Dataset</td><td colspan=\"3\">Cifar10</td><td colspan=\"3\">Cifar100</td></tr><tr><td>Method</td><td>Test acc. (%)</td><td>Reduct. in weights (%)</td><td>Reduct. in MACs (%)</td><td>Test acc. (%)</td><td>Reduct. in weights (%)</td><td>Reduct. in MACs (%)</td></tr><tr><td>VGG-Net*</td><td>94.18</td><td></td><td></td><td>73.45</td><td>=</td><td></td></tr><tr><td>NN Slimming</td><td>85.01</td><td>97.85</td><td>97.89</td><td>58.69</td><td>97.76</td><td>94.09</td></tr><tr><td>NN Slim.+Li</td><td>91.99</td><td>97.93</td><td>86.00</td><td>57.07</td><td>97.59</td><td>93.86</td></tr><tr><td>C-OBD</td><td>92.34 ± 0.18</td><td>97.68 ± 0.02</td><td>77.39 ± 0.36</td><td>58.07 ± 0.60</td><td>97.97 ± 0.04</td><td>77.55 ± 0.25</td></tr><tr><td>EigenDamage</td><td>92.29 ± 0.21</td><td>97.15 ± 0.04</td><td>86.51 ± 0.26</td><td>65.18 ± 0.10</td><td>97.31 ± 0.01</td><td>88.63 ±0.12</td></tr><tr><td>SOSP-I (ours)</td><td>92.62 ± 0.14</td><td>97.79 ± 0.02</td><td>83.52 ±0.29</td><td>64.20 ± 0.23</td><td>97.83 ± 0.04</td><td>87.02 ± 0.20</td></tr><tr><td>SOSP-H(ours)</td><td>92.71 ± 0.19</td><td>97.81 ± 0.01</td><td>86.32 ±0.29</td><td>64.59 ± 0.35</td><td>97.81 ± 0.01</td><td>86.32 ± 0.29</td></tr><tr><td>ResNet-32*</td><td>95.30</td><td></td><td></td><td>76.8</td><td></td><td></td></tr><tr><td>C-OBD</td><td>91.75 ± 0.42</td><td>97.30 ± 0.06</td><td>93.50 ± 0.37</td><td>59.52 ± 0.24</td><td>97.74 ± 0.08</td><td>94.88 ±0.08</td></tr><tr><td>EigenDamage</td><td>93.05 ± 0.23</td><td>96.05 ± 0.03</td><td>94.74 ± 0.02</td><td>65.72 ± 0.04</td><td>95.21 ± 0.04</td><td>94.62 ± 0.06</td></tr><tr><td>SOSP-I(ours)</td><td>92.43 ± 0.09</td><td>95.47 ± 0.33</td><td>94.07 ± 0.66</td><td>67.36 ± 0.46</td><td>92.69 ± 0.07</td><td>95.63 ± 0.13</td></tr><tr><td>SOSP-H(ours)</td><td>92.23 ±0.12</td><td>95.26 ±0.10</td><td>94.45 ±0.40</td><td>68.42 ± 0.21</td><td>94.08 ± 0.21</td><td>95.06 ±0.14</td></tr><tr><td>DenseNet-40*</td><td>94.58</td><td></td><td></td><td>74.11</td><td>=</td><td>=</td></tr><tr><td>NN Slim. + L1</td><td>94.22</td><td>54.21</td><td></td><td>73.19</td><td>54.21</td><td>=</td></tr><tr><td>SOSP-I(ours)</td><td>94.21 ± 0.04</td><td>47.00 ± 0.10</td><td>36.35 ± 0.12</td><td>73.05 ± 0.11</td><td>45.22 ±0.10</td><td>42.05 ±1.16</td></tr><tr><td>SOSP-H(ours)</td><td>94.23 ± 0.05</td><td>49.39 ± 0.65</td><td>38.86 ±0.70</td><td>73.05 ± 0.24</td><td>48.58 ± 0.22</td><td>42.05 ± 0.35</td></tr></table>",
+        "bbox": [
+            202,
+            208,
+            795,
+            434
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/48af209a8c51f5bcc0cf61ffe529ff0027302b639f0fbc2a992cbd6be72f9970.jpg",
+        "image_caption": [
+            "Figure 1: Comparison of SOSP to local, i.e. layer-wise, pruning methods on Cifar10. The best final test accuracy is plotted over the effective number of model parameters (a, c) and MACs (b, d). A tabular representation as well as statistics across trials are shown in App. A.4. SOSP outperforms all competing layer-wise pruning methods, especially over the number of effective parameters. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            199,
+            452,
+            795,
+            597
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "163 3.1 Comparison to Literature ",
+        "text_level": 1,
+        "bbox": [
+            143,
+            684,
+            392,
+            699
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "164 Here we benchmark the performance of our SOSP methods against existing pruning algorithms on   \n165 different datasets and networks. First, we compare against other recent global pruning methods,   \n166 then against local structured pruning methods, i.e. with pre-specified layer-wise pruning rates. In all   \n167 comparisons we report the achieved test accuracy, the number of parameters of the pruned network   \n168 and the MACs (often referred to as FLOPs). To facilitate direct comparisons, we report test accuracies   \n169 in the same way as the competing methods (e.g. best trial or average over trials), but additionally   \n170 report mean and standard deviation of the test error for our models in App. A. Our count of the   \n171 network parameters and MACs is based on the actual pruned network architecture (cf. App. D), even   \n172 though our saliency measure associates with each structure only the weights into this structure.   \n173 We first compare our SOSP methods with global pruning methods on VGG-Net, ResNet-32 and   \n174 DenseNet-40. We use the same variants and implementations of these networks as used by Neural   \n175 Network Slimming (NN Slimming; Liu et al., 2017) as well as EigenDamage and C-OBD (Wang   \n176 et al., 2019a), e.g. capping the layer-wise ratio of removed structures at $9 5 \\%$ for VGGs to prevent   \n177 layer collapse and increasing the width of ResNet-32 by a factor 4. C-OBD is a structured variant of   \n178 the original OBD algorithm (Hassibi et al., 1993), which neglects all cross-structure correlations that,   \n179 in contrast, SOSP takes into account. The results over three trials for high pruning ratios are shown in   \n180 Tab. 1 and for moderate pruning ratios in App. A.1. To enable the comparison to NN Slimming on   \n181 an already pretrained VGG, we included the results of NN Slimming applied to a baseline network   \n182 obtained without modifications to its initial training, i.e. without $L _ { 1 }$ -regularization on the batch  \n183 normalization parameters. For moderate pruning rates, all pruning schemes approximately retain the   \n184 baseline performance for VGG-Net and ResNet-32 on Cifar10 and VGG-Net on Cifar100 (see Tab.   \n185 3). The only exception is the accuracy for C-OBD applied to VGG-Net on Cifar100, which drops by   \n186 approximately $1 \\%$ . For ResNet-32 on Cifar100 the accuracy after pruning is approximately $1 \\%$ lower   \n187 than the baseline, for all pruning schemes. In the regime of larger pruning ratios of approximately $9 7 \\%$ ,   \n188 SOSP and EigenDamage significantly outperform NN Slimming and C-OBD. SOSP performs on par   \n189 with EigenDamage, except for ResNet-32 on Cifar100, where SOSP outperforms EigenDamage by   \n190 almost ${ \\bar { 3 } } \\%$ . This result indicates that SOSP outperforms all other methods especially in the regime of   \n191 baseline networks that have relatively few parameters already and on difficult datasets most relevant   \n192 for applications. For DenseNet-40, we achieve similar results compared to NN Slimming. However,   \n193 note that NN Slimming requires the modification of network pretraining.   \n194 Next, we compare our SOSP methods against four recently published local, i.e. layer-wise, pruning   \n195 algorithms: FPGM He et al. (2019), GAL (Lin et al., 2019), CCP (Peng et al., 2019), Variational   \n196 Pruning (VP; Zhao et al., 2019) and HRank (Lin et al., 2020). For ResNet-56, our SOSP methods   \n197 outperform all other methods across all pruning ratios (see Fig. 1a and b). For DenseNet-40, SOSP   \n198 achieves better accuracies when compared over parameters (Fig. 1c) and is on par with the best other   \n199 methods over MACs (Fig. 1d). The reason for this discrepancy is probably that the SOSP objective is   \n200 agnostic to the number of MACs (image size) in each individual structure. ",
+        "bbox": [
+            140,
+            710,
+            825,
+            835
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/483c6c0104155e99ede5d9497d8add4cd19500ef371eda5c32c92b05467714a5.jpg",
+        "image_caption": [
+            "Figure 2: Runtime to calculate the pruning masks for ResNet-56 on Cifar10 over the width of the network for SOSP-I and SOSP-H. We vary the width of the network by increasing the width of each layer by a multiplicative factor. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            209,
+            98,
+            362,
+            212
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "table",
+        "img_path": "images/17ae1e51113432217a45df2f703767ec8c89d255da5fe854a82753152a18e577.jpg",
+        "table_caption": [
+            "Table 2: Best final test accuracies and pruning ratios (PR) across 2 trials on ImageNet. For comparison to CCP, we also provide their alternative MAC count (for details, see App. D). \\* denotes SOSP with kernel scaling (see main text). SOSP outperforms all three competing methods. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Model</td><td>Top-1% (Gap)</td><td>Parameters (PR)</td><td>MACs (PR)</td><td>Alt. MACs (PR)</td></tr><tr><td>ResNet-18</td><td>69.76 (0.0)</td><td>11.7M (0%)</td><td>1.82B (0%)</td><td>1.82B (0%)</td></tr><tr><td>SOSP (ours)</td><td>69.63 (0.13)</td><td>7.12M (39%)</td><td>1.37B (24%)</td><td>1.31B (28%)</td></tr><tr><td>FPGM</td><td>68.41 (1.87)</td><td>7.10M (39%)</td><td>1.06B (41%)</td><td></td></tr><tr><td>SOSP (ours)</td><td>68.78 (0.98)</td><td>6.42M (45%)</td><td>1.29B (29%)</td><td>1.20B (34%)</td></tr><tr><td>ResNet-50</td><td>76.15 (0.0)</td><td>25.5M (0%)</td><td>3.85B (0%)</td><td>3.85B (0%)</td></tr><tr><td>SOSP (ours)</td><td>76.56(-0.41)</td><td>19.9M(22%)</td><td>3.06B(21%)</td><td>2.72B(29%)</td></tr><tr><td>SOSP*(ours)</td><td>76.60 (-0.45)</td><td>17.9M (30%)</td><td>2.79B (28%)</td><td>2.47B (36%)</td></tr><tr><td>HRank</td><td>74.98 (1.17)</td><td>16.2M(36%)</td><td>2.30B (44%)</td><td></td></tr><tr><td>FPGM</td><td>75.59 (0.56)</td><td>15.9M (37%)</td><td>2.36B (42%)</td><td></td></tr><tr><td>SOSP (ours)</td><td>75.85 (0.30)</td><td>15.4M (40%)</td><td>2.44B (27%)</td><td>1.97B (49%)</td></tr><tr><td>HRank</td><td>71.98 (4.17)</td><td>13.8M (46%)</td><td>1.55B (62%)</td><td></td></tr><tr><td>CCP</td><td>75.21 (0.94)</td><td></td><td></td><td>1.77B (54%)</td></tr><tr><td>SOSP*(ours)</td><td>75.21 (0.94)</td><td>13.0M (49%)</td><td>2.13B (45%)</td><td>1.68B (56%)</td></tr><tr><td>SOSP (ours)</td><td>74.39 (1.76)</td><td>11.8M (54%)</td><td>1.89B (51%)</td><td>1.38B (64%)</td></tr><tr><td>SOSP*(ours)</td><td>73.38 (2.77)</td><td>9.9M (61%)</td><td>1.58B (59%)</td><td>1.10B (72%)</td></tr></table>",
+        "bbox": [
+            428,
+            166,
+            815,
+            329
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            357,
+            825,
+            577
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            583,
+            825,
+            680
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.2 Scalability and application to large-scale datasets ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            699,
+            553,
+            713
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Before going to large datasets, we compare the scalability of our methods SOSP-I and SOSP-H. As the preceding section shows, both methods perform basically on par with each other in terms of accuracy. This confirms that SOSP-H is not degraded by the approximations leading to the efficient Hessian-vector product, or is helped by use of the exact Hessian. In terms of efficiency, however, SOSP-H shows clear advantages compared to SOSP-I, for which the algorithm to select the structures to be pruned scales with ${ \\cal O } ( \\bar { \\cal S } ^ { 3 } )$ (see Sec. 2.3) potentially dominating the overall runtime for large-scale networks. Measurements of the actual runtimes show that already for medium-sized networks SOSP-H is more efficient than SOSP-I (Fig. 2). Since SOSP-I becomes impractical for large-scale networks, for the ImageNet dataset we will only evaluate SOSP-H and refer to it as SOSP. ",
+        "bbox": [
+            171,
+            724,
+            825,
+            849
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "211 On ImageNet, we compare our results to literature for ResNet-18 and ResNet-50, see Tab. 2. Because   \n212 SOSP assesses the sensitivity of each structure independently of the contributed MACs, it has a   \n213 bias towards pruning small-scale structures. This tendency is strongest for ResNet-50, due to its   \n214 $1 \\times 1$ -convolutions. Since these $1 \\times 1$ -convolutions tend to contribute disproportionately little to the   \n215 overall number of MACs, we devised a scaled variant of SOSP, which divides the saliency of every   \n216 structure by the kernel size (e.g. 1, 3 or 7). Compared to the vanilla SOSP, the scaled variant of SOSP   \n217 is able to remove larger percentages of MACs with similar drops in accuracy (see Tab. 2).   \n18 For both networks SOSP outperforms HRank and FPGM, especially when considering the main   \n19 objective of SOSP, which is to reduce the number of parameters or structures. Since CCP uses a   \n20 different way of calculating the MACs, which leads to consistently higher pruning ratios, we added   \nan alternative MAC count to enable a fair comparison (for details, see App. D). Since HRank and   \n22 FPGM do not mention their MAC counting convention, we assume they use the same convention   \n23 as we do. Taking this into account, our scaled SOSP variant is able to prune more MACs than CCP,   \n4 while having the same final accuracy. ",
+        "bbox": [
+            142,
+            856,
+            823,
+            911
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "image",
+        "img_path": "images/8fb16683ecd07c84d01e7d126b43a3a46dffafe4c8863c75d02039274161673b.jpg",
+        "image_caption": [
+            "Figure 3: Comparison between pruning after training and at initialization on Cifar10. Both pruning schemes, train-pruning (a) and init-pruning (b), train the network for the same overall number of epochs, but generate and apply the pruning masks at different point in times. The average and standard deviation of the test accuracy across 3 trials is plotted against the number of model parameters for ResNet-56 (top row; c) and VGG (bottom row; f). For a single trial, in which overall $5 0 \\%$ of the structures are pruned, we visualize the pruning masks of train-pruning and init-pruning by showing the layer-wise pruning ratios in (d, g) and (e, h), respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            197,
+            94,
+            789,
+            282
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            417,
+            825,
+            460
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            155,
+            467,
+            825,
+            564
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.3 Pruning at Initialization ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            580,
+            382,
+            594
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Traditionally, pruning methods are applied to pretrained networks, as also done in the previous sections, but recently there has been growing attention on pruning at initialization following the works of Lee et al. (2018) and Frankle & Carbin (2018). Since SOSP employs the absolute value of the sensitivities, it can also be applied to a randomly initialized network without any modifications. Thus, SOSP can also be seen as an efficient second-order generalization of SNIP (Lee et al., 2018; van Amersfoort et al., 2020). While EigenDamage can in principle be modified and applied to a randomly initialized network, NN Slimming can not be applied at initialization. ",
+        "bbox": [
+            173,
+            606,
+            825,
+            703
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Usually pruning at initialization leads to worse accuracies than pruning after training (Liu et al., 2018). However, pruning an already trained network is often followed by fine-tuning effectively training the network twice (Fig. 3a). For comparability with pruning at initialization, we unify the overall training schedule between these two settings and consequently apply two training cycles after pruning the randomly initialized network (Fig. 3b; for further discussion, see App. A.5). ",
+        "bbox": [
+            174,
+            709,
+            825,
+            779
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "We observe that applying SOSP at initialization performs almost equally well than applying SOSP after training (see ResNet-56 and VGG in Fig. 3c and f, respectively). In conclusion, applying SOSP at initialization can significantly reduce the time and resources required for network training with no or only minor degradation in accuracy. ",
+        "bbox": [
+            176,
+            785,
+            825,
+            840
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Identifying & Removing Architectural Bottlenecks ",
+        "text_level": 1,
+        "bbox": [
+            173,
+            857,
+            563,
+            872
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "43 Even though the previous section highlighted that applying SOSP after training and at initialization   \n244 results in comparable accuracies, the pruning masks differ between these two scenarios (compare Fig.   \n245 3d and g to e and h, resp.). Despite this difference a common feature of all masks is that some layers   \n246 are barely pruned or not pruned at all while others are pruned by up to $8 0 \\%$ . This could indicate   \n247 towards architectural bottlenecks. We consider a layer an architectural bottleneck if the respective   \n248 layer has a considerably lower pruning ratio compared to the other layers. The low pruning ratio of   \n249 bottleneck layers indicates that the substructures (e.g. filters) have a high sensitivity. Thus, widening   \n250 these layers could improve the overall performance and allow for even smaller models with higher   \n251 accuracies.   \n252 To utilize this insight we device a procedure that we call expand-pruning. The idea is to first calculate   \n253 the pruning ratios of a trained network and then to identify architectural bottlenecks, i.e. the layers   \n254 with the lowest pruning ratios. Next, we widen these layers by a factor of two, which has been   \n255 empirically shown to work well. Finally, we randomly initialize, train, prune, and fine-tune the   \n256 expanded network (for a schematic, see Fig. 4a). As a naive baseline that we call the widen-pruning   \n257 procedure, we widen all layers in the network with a constant factor instead of widening specific   \n258 layers. We choose the constant factor such that the overall number of parameters matches that of the   \n259 expand-prune procedure (see width multiplier in Fig. 4).   \n260 We evaluate the expand-pruning procedure for ResNet-56 and VGG on Cifar10, for which we expand   \n261 the least pruned of the three main building blocks and the five least pruned layers, respectively (e.g.,   \n262 see width multipliers in Fig. 4c and f selected on the basis of the pruning masks shown in Fig. 3d and   \n263 g, resp.). Note that for ResNet-56 a more fine-grained removal of bottlenecks, e.g. on layer level,   \n264 is not possible without changing the overall ResNet architecture. In summary, a selective removal   \n265 of bottlenecks results in smaller network models with higher accuracy than pruning the vanilla   \n266 network or unselectively increasing the network size (compare expand-pruning to train-pruning and   \n267 widen-pruning in Fig. 4b and e). While in principle any global pruning method could be used for   \n268 the expand-pruning procedure, SOSP is especially suited since it does not require to modify the   \n269 network architecture like EigenDamage and can also be applied at initialization unlike NN Slimming,   \n270 allowing for a similar expand scheme directly at initialization (see App. A.6). ",
+        "bbox": [
+            151,
+            882,
+            826,
+            911
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "image",
+        "img_path": "images/758a802e57d71e1fa13757cac17fb49c8b78c4a8458b376f4ee85ee474fcfc1d.jpg",
+        "image_caption": [
+            "Figure 4: We remove architectural bottlenecks found by SOSP using the expand-pruning scheme (a) on Cifar10. The width of blocks and layers with low pruning ratios in the train-pruning scheme (Fig. 3d and g) are expanded by a width multiplier of 2 (c, f). As a baseline, we uniformly expand all layers in the network by a factor 1.1 (d, g). The layer-wise pruning ratios of the enlarged network models are shown as bar plots in (c, d, f, g). The average and standard deviation of the test accuracy across 3 trials are shown over the number of model parameters (b, e). Note that the full ResNet-56 and VGG models have $0 . 8 6 \\cdot 1 0 ^ { 6 }$ and $2 0 \\cdot 1 0 ^ { 6 }$ parameters, respectively. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            191,
+            97,
+            799,
+            275
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            412,
+            825,
+            511
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            517,
+            825,
+            628
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            633,
+            825,
+            786
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "271 4 Discussion ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            808,
+            294,
+            825
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "In this work we have demonstrated the effectiveness and scalability of our second-order structured pruning algorithms (SOSP). While both algorithms perform similarly well, SOSP-H is more easily scalable to large scale networks and datasets. We highlighted two major features of our method. Firstly, SOSP can be applied at initialization with only minor degradation in accuracy, which drastically reduces the required time and resources for training. Secondly, we showed that the pruning masks ",
+        "bbox": [
+            158,
+            842,
+            823,
+            911
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "77 found by SOSP can be used to systematically detect and remove architectural bottlenecks, further   \n278 improving the performance of pruned networks.   \n279 Compared to other global pruning methods, SOSP captures correlations between structures by a sim  \n280 ple, effective and scalable algorithm that neither requires to modify the training nor the architecture of   \n281 the to be pruned network model and achieves comparable or better accuracies on benchmark datasets.   \n282 The C-OBD algorithm (Wang et al., 2019a) is a structured generalization of the original unstructured   \n283 OBD algorithm (LeCun et al., 1990). In contrast to OBD, C-OBD accounts for correlations within   \n284 each structure, but does not capture correlations between different structures within and across layers.   \n285 We show that considering these global correlations consistently improve the performance, especially   \n286 for large pruning ratios (Tab. 1). This observation is further confirmed by an ablation study in which   \n287 we neglect all cross-structure correlations significantly decreasing the performance under otherwise   \n288 identical experimental settings (App. A.2). The objective of EigenDamage (Wang et al., 2019a) to   \n289 include second order correlations is similar to ours, but the approaches are significantly different.   \n290 EigenDamage uses the Fisher-approximation, which is similar to the Gauss-Newton approximation   \n291 used for SOSP-I, and then, in addition to further approximations, apply low rank approximations   \n292 that require the substitution of each layer by a bottleneck-block structure. Our SOSP method is   \n293 simpler, easier to implement and does not require to modify the network architecture, but nevertheless   \n294 performs on par with EigenDamage. The approach of NN Slimming (Liu et al., 2017) is more   \n295 heuristic than SOSP and is easy to implement. However, networks need to be pretrained with $L _ { 1 }$   \n296 regularization on the batch-normalization parameters, otherwise the performance is severly harmed   \n297 (Tab. 1 and 3). SOSP does not require any modifications to the network training and can be applied   \n298 to any pretrained network. A recent variant of NN Slimming was developed by Zhuang et al. (2020)   \n299 who optimize their hyperparameters to reduce the number of MACs. Using the number MACs as an   \n300 objective for SOSP is left for future studies.   \n301 In addition to the above comparison to other global pruning methods, we also compared our methods   \n302 to simpler local pruning methods that keep the pruning ratios constant for each layer and, consequently,   \n303 scale well to large-scale datasets. The pruning method closest to our SOSP-I method is the one by   \n304 Peng et al. (2019). While both works consider second-order correlations between structures, theirs is   \n305 based on a pruning objective different from our absolute sensitivites in $\\lambda _ { 2 } ^ { I }$ and considers only intra  \n306 layer correlations. Furthermore, they employ an auxiliary classifier with a hyperparameter, yielding   \n307 accuracy improvements that are difficult to disentangle from the effect of second-order pruning. Going   \n308 beyond a constant pruning ratio for each layer Su et al. (2020) discovered, for ResNets, that pruning   \n309 at initialization seems to preferentially prune initial layers and thus proposed a pruning scheme based   \n310 on a “keep-ratio” per layer which increases with the depth of the network. Our experiments confirm   \n311 some of the findings of Su et al. (2020), but we also show that the specific network architectures found   \n312 by pruning can drastically vary between different networks and especially between initialization and   \n313 after training (histograms in Fig. 3). While all local pruning methods specify pruning ratios for each   \n314 layer, our method performs automatic selection across layers (histograms in Fig. 3).   \n315 This automatic selection allows us to identify and remove architectural bottlenecks. However, our   \n316 global pruning method has a bias towards pruning small structures, absent from local pruning methods,   \n317 as the size of structures is usually identical within layers. We propose a simple solution by scaling   \n318 each structure by the inverse of the kernel size which helps to remove some of the bias. Alternatively,   \n319 to better reflect the computational costs in real-world applications, each structure could also be   \n320 normalized by the number of its required MACs (like done by van Amersfoort et al., 2020).   \n321 Recently, unstructured (Lee et al., 2018; Wang et al., 2019b; Tanaka et al., 2020) and structured   \n322 (van Amersfoort et al., 2020; Hayou et al., 2021) pruning schemes that are applicable to networks   \n323 at initialization were proposed. While these methods fail to achieve similar accuracies compared to   \n324 pruning after training, our SOSP method in the init-pruning setting achieves accuracies comparable   \n325 to pruning after training. ",
+        "bbox": [
+            150,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            125,
+            825,
+            430
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            435,
+            825,
+            628
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            636,
+            825,
+            718
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            724,
+            825,
+            795
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In accordance with Elsken et al. (2019), our results suggest that pruning can be used to optimize the architectural hyperparameters of established networks (Liu et al., 2018) or super-graphs (Noy et al., 2020). Instead of formulating this optimization as a pruning process, we envision our second-order sensitivity analysis to be a valuable tool to identify and remove bottlenecks to find good neural architectures more quickly. For example, whenever a building block of the neural network cannot be compressed, this building block may be considered a bottleneck of the architecture and could be inflated to improve the overall trade-off between accuracy and computational cost. ",
+        "bbox": [
+            168,
+            800,
+            825,
+            897
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "text_level": 1,
+        "bbox": [
+            171,
+            90,
+            267,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "References   \n334 Blalock, D., Ortiz, J. J. G., Frankle, J., and Guttag, J. What is the state of neural network pruning? arXiv preprint arXiv:2003.03033, 2020.   \n336 Deng, J., Dong, W., Socher, R., Li, L.-J., Li, K., and Fei-Fei, L. Imagenet: A large-scale hierarchical image database. In 2009 IEEE conference on computer vision and pattern recognition, pp. 248–255. Ieee, 2009.   \n339 Elsken, T., Metzen, J. H., and Hutter, F. Neural architecture search: A survey. Journal of Machine Learning Research, 20(55):1–21, 2019. Fletcher, R. Practical methods of optimization. John Wiley & Sons, 2013. Frankle, J. and Carbin, M. The lottery ticket hypothesis: Finding sparse, trainable neural networks. In International Conference on Learning Representations, 2018. Han, S., Pool, J., Tran, J., and Dally, W. Learning both weights and connections for efficient neural network. Advances in neural information processing systems, 28:1135–1143, 2015. Hassibi, B., Stork, D. G., and Wolff, G. J. Optimal brain surgeon and general network pruning. In IEEE international conference on neural networks, pp. 293–299. IEEE, 1993. Hayou, S., Ton, J.-F., Doucet, A., and Teh, Y. W. Robust pruning at initialization. In International Conference on Learning Representations, 2021. URL https://openreview.net/forum?id= vXj_ucZQ4hA.   \n351 He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.   \n353 He, Y., Zhang, X., and Sun, J. Channel pruning for accelerating very deep neural networks. In Proceedings of the IEEE International Conference on Computer Vision, pp. 1389–1397, 2017. He, Y., Liu, P., Wang, Z., Hu, Z., and Yang, Y. Filter pruning via geometric median for deep convolutional neural networks acceleration. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 4340–4349, 2019. Huang, G., Liu, Z., Van Der Maaten, L., and Weinberger, K. Q. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.   \n361 Jacot, A., Gabriel, F., and Hongler, C. Neural tangent kernel: convergence and generalization in neural networks. In Proceedings of the 32nd International Conference on Neural Information Processing Systems, pp. 8580–8589, 2018.   \nKrizhevsky, A., Hinton, G., et al. Learning multiple layers of features from tiny images. 2009.   \n365 LeCun, Y., Denker, J. S., and Solla, S. A. Optimal brain damage. In Advances in neural information processing systems, pp. 598–605, 1990.   \n367 Lee, N., Ajanthan, T., and Torr, P. Snip: Single-shot network pruning based on connection sensitivity. In International Conference on Learning Representations, 2018. Lin, M., Ji, R., Wang, Y., Zhang, Y., Zhang, B., Tian, Y., and Shao, L. Hrank: Filter pruning using high-rank feature map. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 1529–1538, 2020.   \n372 Lin, S., Ji, R., Yan, C., Zhang, B., Cao, L., Ye, Q., Huang, F., and Doermann, D. Towards optimal structured cnn pruning via generative adversarial learning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2790–2799, 2019. Liu, Z., Li, J., Shen, Z., Huang, G., Yan, S., and Zhang, C. Learning efficient convolutional networks through network slimming. In Proceedings of the IEEE International Conference on Computer Vision (ICCV), Oct 2017.   \nLiu, Z., Sun, M., Zhou, T., Huang, G., and Darrell, T. Rethinking the value of network pruning. In International Conference on Learning Representations, 2018.   \nMingjie, S. and Zhuang, L. Network slimming. https://github.com/Eric-mingjie/ network-slimming, 2018.   \nNoy, A., Nayman, N., Ridnik, T., Zamir, N., Doveh, S., Friedman, I., Giryes, R., and Zelnik, L. ASAP: Architecture search, anneal and prune. In Chiappa, S. and Calandra, R. (eds.), Proceedings of the Twenty Third International Conference on Artificial Intelligence and Statistics, volume 108 of Proceedings of Machine Learning Research, pp. 493–503, 2020.   \nPeng, H., Wu, J., Chen, S., and Huang, J. Collaborative channel pruning for deep networks. In International Conference on Machine Learning, pp. 5113–5122. PMLR, 2019.   \nReed, R. Pruning algorithms-a survey. IEEE transactions on Neural Networks, 4(5):740–747, 1993.   \nSimonyan, K. and Zisserman, A. Very deep convolutional networks for large-scale image recognition. arXiv preprint arXiv:1409.1556, 2014.   \nSu, J., Chen, Y., Cai, T., Wu, T., Gao, R., Wang, L., and Lee, J. D. Sanity-checking pruning methods: Random tickets can win the jackpot. In Advances in Neural Information Processing Systems, 2020.   \nTanaka, H., Kunin, D., Yamins, D. L., and Ganguli, S. Pruning neural networks without any data by iteratively conserving synaptic flow. Advances in Neural Information Processing Systems, 33, 2020.   \nTang, Y., Wang, Y., Xu, Y., Tao, D., Xu, C., Xu, C., and Xu, C. Scop: Scientific control for reliable neural network pruning. Advances in Neural Information Processing Systems, 2020.   \nvan Amersfoort, J., Alizadeh, M., Farquhar, S., Lane, N., and Gal, Y. Single shot structured pruning before training. arXiv preprint arXiv:2007.00389, 2020.   \nWang, C., Grosse, R., Fidler, S., and Zhang, G. Eigendamage: Structured pruning in the kroneckerfactored eigenbasis. In International Conference on Machine Learning, pp. 6566–6575, 2019a.   \nWang, C., Zhang, G., and Grosse, R. Picking winning tickets before training by preserving gradient flow. In International Conference on Learning Representations, 2019b.   \nZhao, C., Ni, B., Zhang, J., Zhao, Q., Zhang, W., and Tian, Q. Variational convolutional neural network pruning. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 2780–2789, 2019.   \nZhuang, T., Zhang, Z., Huang, Y., Zeng, X., Shuang, K., and Li, X. Neuron-level structured pruning using polarization regularizer. Advances in Neural Information Processing Systems, 33, 2020. ",
+        "bbox": [
+            150,
+            94,
+            828,
+            915
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            153,
+            87,
+            828,
+            654
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Checklist ",
+        "text_level": 1,
+        "bbox": [
+            165,
+            671,
+            254,
+            688
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "1. For all authors... ",
+        "bbox": [
+            214,
+            698,
+            339,
+            712
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope? [Yes]   \n(b) Did you describe the limitations of your work? [Yes]   \n(c) Did you discuss any potential negative societal impacts of your work? [N/A]   \n(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] ",
+        "bbox": [
+            238,
+            717,
+            825,
+            808
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "2. If you are including theoretical results... ",
+        "bbox": [
+            214,
+            811,
+            493,
+            825
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you state the full set of assumptions of all theoretical results? [Yes] (b) Did you include complete proofs of all theoretical results? [Yes] ",
+        "bbox": [
+            236,
+            829,
+            733,
+            861
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "3. If you ran experiments... ",
+        "bbox": [
+            214,
+            864,
+            393,
+            880
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)? [Yes] ",
+        "bbox": [
+            236,
+            883,
+            823,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes]   \n(c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)? [Yes]   \n(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] ",
+        "bbox": [
+            236,
+            90,
+            825,
+            180
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... ",
+        "bbox": [
+            209,
+            184,
+            823,
+            199
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) If your work uses existing assets, did you cite the creators? [Yes]   \n(b) Did you mention the license of the assets? [Yes]   \n(c) Did you include any new assets either in the supplemental material or as a URL? [Yes]   \n(d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating? [N/A]   \n(e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content? [N/A] ",
+        "bbox": [
+            238,
+            203,
+            823,
+            310
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "5. If you used crowdsourcing or conducted research with human subjects... ",
+        "bbox": [
+            214,
+            314,
+            705,
+            329
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "(a) Did you include the full text of instructions given to participants and screenshots, if applicable? [N/A]   \n(b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable? [N/A]   \n(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] ",
+        "bbox": [
+            238,
+            333,
+            825,
+            422
+        ],
+        "page_idx": 11
+    }
+]

parse/train/umIdUL8rMH/umIdUL8rMH.md

@@ -0,0 +1,488 @@
+# BOIL: TOWARDS REPRESENTATION CHANGE FOR FEW-SHOT LEARNING
+
+Jaehoon $\mathbf { O } \mathbf { h } ^ { * 1 }$ , Hyungjun $\mathbf { V o o ^ { * 1 } }$ , ChangHwan $\mathbf { K i m ^ { 1 } }$ & Se-Young $\mathbf { Y u n ^ { 2 } }$
+
+1Graduate School of Knowledge Service Engineering, KAIST 2Graduate School of Artificial Intelligence, KAIST {jaehoon.oh,yoohjun,kimbob,yunseyoung}@kaist.ac.kr
+
+# ABSTRACT
+
+Model Agnostic Meta-Learning (MAML) is one of the most representative of gradient-based meta-learning algorithms. MAML learns new tasks with a few data samples using inner updates from a meta-initialization point and learns the meta-initialization parameters with outer updates. It has recently been hypothesized that representation reuse, which makes little change in efficient representations, is the dominant factor in the performance of the meta-initialized model through MAML in contrast to representation change, which causes a significant change in representations. In this study, we investigate the necessity of representation change for the ultimate goal of few-shot learning, which is solving domain-agnostic tasks. To this aim, we propose a novel meta-learning algorithm, called BOIL (Body Only update in Inner Loop), which updates only the body (extractor) of the model and freezes the head (classifier) during inner loop updates. BOIL leverages representation change rather than representation reuse. This is because feature vectors (representations) have to move quickly to their corresponding frozen head vectors. We visualize this property using cosine similarity, CKA, and empirical results without the head. BOIL empirically shows significant performance improvement over MAML, particularly on cross-domain tasks. The results imply that representation change in gradient-based meta-learning approaches is a critical component.
+
+# 1 INTRODUCTION
+
+Meta-learning, also known as “learning to learn,” is a methodology that imitates human intelligence that can adapt quickly with even a small amount of previously unseen data through the use of previous learning experiences. To this aim, meta-learning with deep neural networks has mainly been studied using metric- and gradient-based approaches. Metric-based meta-learning (Koch, 2015; Vinyals et al., 2016; Snell et al., 2017; Sung et al., 2018) compares the distance between feature embeddings using models as a mapping function of data into an embedding space, whereas gradient-based meta-learning (Ravi & Larochelle, 2016; Finn et al., 2017; Nichol et al., 2018) quickly learns the parameters to be optimized when the models encounter new tasks.
+
+Model-agnostic meta-learning (MAML) (Finn et al., 2017) is the most representative gradient-based meta-learning algorithm. MAML algorithm consists of two optimization loops: an inner loop and an outer loop. The inner loop learns task-specific knowledge, and the outer loop finds a universally good meta-initialized parameter allowing the inner loop to quickly learn any task from the initial point with only a few examples. This algorithm has been highly influential in the field of meta-learning, and numerous follow-up studies have been conducted (Oreshkin et al., 2018; Rusu et al., 2018; Zintgraf et al., 2018; Yoon et al., 2018; Finn et al., 2018; Triantafillou et al., 2019; Sun et al., 2019; Na et al., 2019; Tseng et al., 2020).
+
+Very recent studies (Raghu et al., 2020; Arnold et al., 2019) have attributed the success of MAML to high-quality features before the inner updates from the meta-initialized parameters. For instance, Raghu et al. (2020) claimed that MAML learns new tasks by updating the head (the last fully connected layer) with almost the same features (the output of the penultimate layer) from the metainitialized network. In this paper, we categorize the learning patterns as follows: A small change in the representations during task learning is named representation reuse, whereas a large change is named representation change.1 Thus, representation reuse was the common belief of MAML.
+
+![](images/60770b75cfb25b27498ef2c163681908f3488be3d0fd7b0c1678543cf027337d.jpg)  
+Figure 1: Difference in task-specific (inner) updates between MAML/ANIL and BOIL. In the figure, the lines represent the decision boundaries defined by the head (classifier) of the network. Different shapes and colors mean different classes. (a) MAML mainly updates the head with a negligible change in body (extractor); hence, representations on the feature space are almost identical. ANIL does not change in the body during inner updates, and they are therefore identical. However, (b) BOIL updates only the body without changing the head during inner updates; hence, representations on the feature space change significantly with the fixed decision boundaries. We visualize the representations from various data sets using UMAP (Uniform Manifold Approximation and Projection for dimension reduction) (McInnes et al., 2018) in Appendix B.
+
+Herein, we pose an intriguing question: Is representation reuse sufficient for meta-learning? We believe that the key to successful meta-learning is closer to representation change than to representation reuse. More importantly, representation change is crucial for cross-domain adaptation, which is considered the ultimate goal of meta-learning. By contrast, the MAML accomplished with representation reuse might be poorly trained for cross-domain adaptation since the success of representation reuse might rely heavily on the similarity between the source and the target domains.
+
+To answer this question, we propose a novel meta-learning algorithm that leverages representation change. Our contributions can be summarized as follows:
+
+• We emphasize the necessity of representation change for meta-learning through crossdomain adaptation experiments.   
+• We propose a simple but effective meta-learning algorithm that learns the Body (extractor) of the model Only in the Inner Loop (BOIL). We empirically show that BOIL improves the performance over most of benchmark data sets and that this improvement is particularly noticeable in fine-grained data sets or cross-domain adaptation.   
+• We interpret the connection between BOIL and the algorithm using preconditioning gradients (Flennerhag et al., 2020) and show their compatibility, improving performance.   
+• We demonstrate that the BOIL algorithm enjoys representation layer reuse on the low-/midlevel body and representation layer change on the high-level body using the cosine similarity and the Centered Kernel Alignment (CKA). We visualize the features between before and after an adaptation, and empirically analyze the effectiveness of the body of BOIL through an ablation study on eliminating the head.   
+For ResNet architectures, we propose a disconnection trick that removes the backpropagation path of the last skip connection. The disconnection trick strengthens representation layer change on the high-level body.
+
+# 2 PROBLEM SETTING
+
+# 2.1 META-LEARNING FRAMEWORK (MAML)
+
+The MAML algorithm (Finn et al., 2017) attempts to meta-learn the best initialization of the parameters for a task-learner. It consists of two main optimization loops: an inner loop and an outer loop. First, we sample a batch of tasks within a data set distribution. Each task $\tau _ { i }$ consists of a support set $S _ { \tau _ { i } }$ and a query set $Q _ { \tau _ { i } }$ . When we sample a support set for each task, we first sample $n$ labels from the label set and then sample $k$ instances for each label. Thus, each support set contains $n \times k$ instances. For a query set, we sample instances from the same labels with the support set.
+
+With these tasks, the MAML algorithm conducts both meta-training and meta-testing. During metatraining, we first sample a meta-batch consisting of $B$ tasks from the meta-training data set. In the inner loops, we update the meta-initialized parameters $\theta$ to task-specific parameters $\theta _ { \tau _ { \dot { 3 } } }$ using the task-specific loss $L _ { S _ { \tau _ { i } } } ( f _ { \theta } )$ , where $f _ { \theta }$ is a neural network parameterized by $\theta$ , as follows:2
+
+$$
+\theta _ { \tau _ { i } } = \theta - \alpha \nabla _ { \theta } L _ { S _ { \tau _ { i } } } ( f _ { \theta } )
+$$
+
+Using the query set of the corresponding task, we compute the loss $L _ { Q _ { \tau _ { i } } } ( f _ { \theta _ { \tau _ { i } } } )$ based on each inner updated parameter. By summing all these losses, the meta-loss of each meta-batch, $L _ { m e t a } ( \theta )$ , is computed. The meta-initialized parameters are then updated using the meta-loss in the outer loop through a gradient descent.
+
+$$
+\theta ^ { \prime } = \theta - \beta \nabla _ { \theta } L _ { m e t a } ( \theta ) , \mathrm { w h e r e } L _ { m e t a } ( \theta ) = \sum _ { i = 1 } ^ { B } L _ { Q _ { \tau _ { i } } } ( f _ { \theta _ { \tau _ { i } } } )
+$$
+
+In meta-testing, the inner loop, which can be interpreted as task-specific learning, is the same as in meta-training. However, the outer loop only computes the accuracy using a query set of tasks and does not perform a gradient descent; thus, it does not update the meta-initialization parameters.
+
+# 2.2 EXPERIMENTAL SETUP
+
+We used two backbone networks, 4conv network with 64 channels from Vinyals et al. (2016) and ResNet-12 starting with 64 channels and doubling them after every block from Oreshkin et al. (2018). For the batch normalization, we used batch statistics instead of the running statistics during metatesting, following the original MAML (Finn et al., 2017). We trained 4conv network and ResNet-12 for 30,000 and 10,000 epochs, respectively, and then used the model with the best accuracy on metavalidation data set to verify the performance. We applied an inner update once for both meta-training and meta-testing. The outer learning rate was set to 0.001 and 0.0006 and the inner learning rate was set to 0.5 and 0.3 for 4conv network and ResNet-12, respectively. All results were reproduced by our group and reported as the average and standard deviation of the accuracies over $5 \times 1 { , } 0 0 0$ tasks, and the values in parentheses in the algorithm name column of the tables are the number of shots. We validated both MAML/ANIL and BOIL on two general data sets, miniImageNet (Vinyals et al., 2016) and tieredImageNet (Ren et al., 2018), and two specific data sets, Cars (Krause et al., 2013) and CUB (Welinder et al., 2010). Note that our algorithm is not for state-of-the-art performance but for a proposal of a new learning scheme for meta-learning. Full details on the implementation and data sets are described in Appendix A.3 In addition, the results of the other data sets at a size of $3 2 \times$ 32 and using the 4conv network with 32 channels from Finn et al. (2017) (i.e., original setting) are reported in Appendix C and Appendix D, respectively.
+
+# 3 BOIL (BODY ONLY UPDATE IN INNER LOOP)
+
+3.1 THE ULTIMATE GOAL OF META-LEARNING: DOMAIN-AGNOSTIC ADAPTATION
+
+Recently, Raghu et al. (2020) proposed two opposing hypotheses, representation reuse and representation change, and demonstrated that representation reuse is the dominant factor of MAML. We can discriminate two hypotheses according to which part of the neural network, body or head, is mostly updated through the inner loop. Here, the body indicates all convolutional layers, and the head indicates the remaining fully connected layer. In other words, the representation change hypothesis attributes the capability of MAML to the updates on the body, whereas the representation reuse hypothesis considers that the network body is already universal to various tasks before the inner loops. To demonstrate the representation reuse hypothesis of MAML, the authors proposed the ANIL (Almost No Inner Loop) algorithm, which only updates the head in the inner loops during training and testing, and showed that ANIL has a performance comparable to that of MAML. This implies that the representation trained by MAML/ANIL, even before updated task-specifically, is sufficient to achieve the desired performance. Furthermore, they proposed the NIL-testing (No Inner Loop) algorithm, which removes the head and performs unseen tasks using only the distance between the representations of a support set and those of a query set during testing to identify the capability of representation reuse. NIL-testing of MAML also achieves a performance comparable to MAML. Based on these results, it was claimed that the success of MAML is attributed to representation reuse.
+
+Here, we investigate the necessity of representation change. We believe that the meta-trained models should achieve a good performance in many other domains, which is referred to as domain-agnostic adaptation in this paper. To this end, representation reuse is not appropriate since representation reuse uses the similarity between the source and target domains. The higher the similarity, the higher the efficiency. Therefore, when there are no strong similarities between the source and target domains, good representations for the source domain could be imperfect representations for the target domain. Table 2, which lists our experimental results on cross-domain tasks, shows that the MAML enjoying representation reuse is worse than BOIL leveraging representation change, which will be discussed in detail in the next section.
+
+# 3.2 BOIL ALGORITHM
+
+Inspired by the necessity, we design an algorithm that updates only the body of the model and freezes the head of the model during the task learning to enforce representation change through inner updates. Because the gradients must be back-propagated to update the body, we set the learning rate of the head to zero in the inner updates during both meta-training and meta-testing. Otherwise, the learning and evaluation procedures of BOIL are the same as those of MAML. Therefore, the computational overhead does not change.
+
+Formally speaking, with the notations used in Section 2.1, the meta-initialized parameters $\theta$ can be separated into body parameters $\theta _ { b }$ and head parameters $\theta _ { h }$ , that is, $\theta = \left\{ \theta _ { b } , \theta _ { h } \right\}$ . For a sample image $x \in \mathbb { R } ^ { i }$ , an output can be expressed as $\hat { y } = f _ { \theta } ( x ) = f _ { \theta _ { h } } ( f _ { \theta _ { b } } ( x ) ) \in \bar { \mathbb { R } ^ { n } }$ , where $f _ { \theta _ { b } } ( x ) \in \mathbb { R } ^ { d }$ . The task-specific body parameters $\theta _ { b , \tau _ { i } }$ and head parameters $\theta _ { h , \tau _ { i } }$ through an inner loop given task $\tau _ { i }$ are thus as follows:
+
+$$
+\theta _ { b , \tau _ { i } } = \theta _ { b } - \alpha _ { b } \nabla _ { \theta _ { b } } L _ { S _ { \tau _ { i } } } ( f _ { \theta } ) \ \& \ \theta _ { h , \tau _ { i } } = \theta _ { h } - \alpha _ { h } \nabla _ { \theta _ { h } } L _ { S _ { \tau _ { i } } } ( f _ { \theta } )
+$$
+
+where $\alpha _ { b }$ and $\alpha _ { h }$ are the inner loop learning rates corresponding to the body and head, respectively. MAML usually sets $\alpha = \alpha _ { b } = \alpha _ { h } ( \neq 0 )$ , ANIL sets $\alpha _ { b } = 0$ and $\alpha _ { h } \neq 0$ , and BOIL sets $\alpha _ { b } \neq 0$ and $\alpha _ { h } = 0$ .
+
+These simple differences force the change in the dominant factor of task-specific updates, from the head to the body. Figure 1 shows the main difference in the inner updates between MAML/ANIL and BOIL. To solve new tasks, the head mainly or only changes in MAML/ANIL (Raghu et al., 2020), whereas in BOIL, the body changes.
+
+# 3.2.1 PERFORMANCE IMPROVEMENT ON BENCHMARK DATA SETS AND CROSS-DOMAIN TASKS
+
+Table 1: Test accuracy $( \% )$ of 4conv network on benchmark data sets. The values in parenthesis in the algorithm name column of tables are the number of shots.   
+
+<table><tr><td>Domain</td><td colspan="2">General (Coarse-grained)</td><td colspan="2">Specific (Fine-grained)</td></tr><tr><td>Dataset</td><td>miniImageNet</td><td>tieredImageNet</td><td>Cars</td><td>CUB</td></tr><tr><td>MAML(1)</td><td>47.44 ± 0.23</td><td>47.44 ± 0.18</td><td>45.27±0.26</td><td>56.18±0.37</td></tr><tr><td>ANIL(1)</td><td>47.82 ± 0.20</td><td>49.35 ± 0.26</td><td>46.81 ± 0.24</td><td>57.03 ± 0.41</td></tr><tr><td>BOIL(1)</td><td>49.61 ± 0.16</td><td>48.58 ± 0.27</td><td>56.82 ± 0.21</td><td>61.60 ± 0.57</td></tr><tr><td>MAML(5)</td><td>61.75± 0.42</td><td>64.70±0.14</td><td>53.23±0.26</td><td>69.66±0.03</td></tr><tr><td>ANIL(5)</td><td>63.04 ±0.42</td><td>65.82 ± 0.12</td><td>61.95 ± 0.38</td><td>70.93 ± 0.28</td></tr><tr><td>BOIL(5)</td><td>66.45 ± 0.37</td><td>69.37 ± 0.12</td><td>75.18 ± 0.21</td><td>75.96 ± 0.17</td></tr></table>
+
+Table 1 and Table 2 display the superiority of BOIL on most benchmark data sets and on cross-domain adaptation tasks, where the source and target domains differ (i.e., the meta-training and meta-testing data sets are different). In Table 1, the performance improvement is particularly noticeable on the specific domain data sets Cars and CUB. The results demonstrate that representation change is necessary even if there is a similarity between the source and target domains. Table 2 shows that BOIL is closer to the ultimate goal of meta-learning, which is a domain-agnostic adaptation.
+
+Table 2: Test accuracy $( \% )$ of 4conv network on cross-domain adaptation.   
+
+<table><tr><td>adaptation</td><td colspan="2">General to General</td><td colspan="2">General to Specific</td><td colspan="2">Specific to General</td><td colspan="2">Specific to Specific</td></tr><tr><td>meta-train</td><td>tieredImageNetminiImageNet</td><td></td><td>miniImageNetminiImageNet</td><td></td><td>Cars</td><td>Cars</td><td>CUB</td><td>Cars</td></tr><tr><td>meta-test</td><td></td><td>miniImageNet tieredImageNet</td><td>Cars</td><td>CUB</td><td></td><td>miniImageNet tieredImageNet</td><td>Cars</td><td>CUB</td></tr><tr><td>MAML(1)</td><td>47.60 ± 0.24</td><td>51.61 ± 0.20</td><td>33.57± 0.14</td><td>40.51 ± 0.08</td><td>26.95 ± 0.15</td><td>28.46±0.18</td><td></td><td>32.22±0.30 29.64±0.19</td></tr><tr><td>ANIL(1)</td><td>49.67 ± 0.31</td><td>52.82 ±0.29</td><td>34.77 ± 0.31</td><td>41.12 ± 0.15</td><td>28.67 ± 0.17</td><td>29.41 ± 0.19</td><td></td><td>33.07 ±0.43 28.32 ± 0.32</td></tr><tr><td>BOIL(1)</td><td>49.74± 0.26</td><td>53.23 ±0.41</td><td>36.12 ± 0.29</td><td>44.20± 0.15</td><td>33.71±0.13</td><td>34.06± 0.20</td><td></td><td>35.44± 0.46 34.79±0.27</td></tr><tr><td>MAML(5)</td><td>65.22±0.20</td><td>65.76±0.27</td><td>44.56± 0.21</td><td>53.09±0.16</td><td>30.64±0.19</td><td>32.62±0.21</td><td></td><td>41.24±0.21 32.18 ± 0.13</td></tr><tr><td>ANIL(5)</td><td>66.47 ± 0.16</td><td>66.52 ± 0.28</td><td>46.55± 0.29</td><td>55.82 ± 0.21</td><td>35.38 ± 0.10</td><td>36.94 ± 0.10</td><td></td><td>43.05 ± 0.23 37.99 ±0.15</td></tr><tr><td>BOIL(5)</td><td>69.33 ± 0.19</td><td>69.37 ± 0.23</td><td>50.64±0.22</td><td>60.92 ± 0.11</td><td>44.51± 0.25</td><td>46.09±0.23</td><td></td><td>47.30 ± 0.22 45.91 ± 0.28</td></tr></table>
+
+Recently, Guo et al. (2019) noted that existing meta-learning algorithms have weaknesses in terms of cross-domain adaptation. We divide the cross-domain adaptation into four cases: general to general, general to specific, specific to general, and specific to specific. Previous studies considered the cross-domain scenario from a general domain to a specific domain (Chen et al., 2019; Guo et al., 2019). In this paper, we also evaluate the reverse case. BOIL outperforms MAML/ANIL not only on the typical cross-domain adaptation scenario but also on the reverse one. In particular, the performance improvement, when the domain changes from birds (CUB as a meta-train set) to cars (Cars as a meta-test set), implies that the representation change in BOIL enables the model to adapt to an unseen target domain that is entirely different from the source domain.
+
+# 3.2.2 ABLATION STUDY ON THE LEARNING RATE OF THE HEAD
+
+In this section, we control the inner loop update learning rate of the head to verify the effect of training the head to the performance. The results are depicted in Table 3. The best performance is achieved when the learning rate is 0 (BOIL). However, the accuracy rapidly decreases as the learning rate of the head grows. Even with $1 / 1 0 \times$ head learning rate compared to other layers, the test accuracies are significantly degraded. Therefore, it is thought that freezing head is crucial.
+
+<table><tr><td>Head&#x27;s Learning Rate (αh)</td><td>miniImageNet</td><td>Cars</td></tr><tr><td>0.00 (BOIL)</td><td>66.45± 0.37</td><td>75.18± 0.21</td></tr><tr><td>0.05</td><td>38.81±0.21</td><td>68.67 ±0.21</td></tr><tr><td>0.10</td><td>49.49 ± 0.16</td><td>68.86±0.30</td></tr><tr><td>0.5 (MAML in ours)</td><td>61.75 ± 0.42</td><td>53.23 ±0.26</td></tr></table>
+
+Table 3: 5-Way 5-Shot test accuracy according to the learning rate of the head.
+
+# 3.2.3 BOIL AND PRECONDITIONING GRADIENTS
+
+Some aspects of BOIL can be explained by preconditioning gradients (Lee & Choi, 2018; Flennerhag et al., 2020). Preconditioning gradients occur when a particular layer is shared over all tasks, warping the spaces (e.g., rotating and scaling). For instance, one might consider the frozen head of BOIL to be a warp layer of the entire body (Flennerhag et al., 2020).
+
+Preconditioning gradients can avoid overfitting in a high-capacity model (Flennerhag et al., 2020), and such a benefit is still valid with BOIL. Indeed, many prior studies have suffered from an overfitting problem, and thus it is challenging to train the backbone network more extensively than the 4conv network with 32 filters (Finn et al., 2017). By contrast, BOIL can increase the validation accuracy with more extensive networks. The accuracy of models with 32, 64, and 128 filters continues to increase to 64.02, 66.72, and 69.23, without overfitting. In Appendix E, we report these results as well as the training and valid accuracy curves of BOIL for three different network sizes, in which the larger networks are trained well. We further hypothesize that the head is the most critical part of an overfitting problem, and BOIL can succeed in dealing with the problem by simply ignoring the head in the inner loops.
+
+However, one essential difference between BOIL and the preconditioning gradients is whether the head is frozen. Prior studies did not freeze the last fully connected layer or used any additional fully connected layer to precondition the gradients, and hence representation reuse is still the major factor of their training. To the best of our knowledge, BOIL is the first approach that enforces representation change by freezing the head in the inner loops.
+
+To investigate the gain from representation change, we adapt BOIL to WarpGrad (Flennerhag et al., 2020).4 Four different models are tested, the architectures of which are fully described in Appendix F. Table 4 shows the test accuracy of the four models, where the BOIL-WarpGrad
+
+<table><tr><td>Model</td><td>Accuracy</td></tr><tr><td>WarpGradw/last warp head</td><td>83.19± 0.79</td></tr><tr><td>WarpGrad w/o last warp head</td><td>83.16±0.69</td></tr><tr><td>BOIL-WarpGrad w/ last warp conv</td><td>83.68 ±0.82</td></tr><tr><td>BOIL-WarpGrad w/o last warp conv</td><td>84.88 ±0.42</td></tr></table>
+
+Table 4: Test accuracy $\% )$ of WarpGrad and BOIL-WarpGrad over $5 \times 1 0 0$ tasks.
+
+models freeze the fully connected layer from the corresponding WarpGrad model. It is observed that BOIL-WarpGrad improves WarpGrad and BOIL-WarpGrad without the last warp conv improves BOIL-WarpGrad with the last warp conv. The latter result indicates that, to support BOIL, the last convolution layer must not be fixed but rather updated during the inner loops.
+
+# 4 REPRESENTATION CHANGE IN BOIL
+
+# 4.1 REPRESENTATION CHANGE BEFORE/AFTER ADAPTATION
+
+![](images/4e137e476bdda4fec66b4c9174ebb4d1b644f5d7c6f6ae3b75b14ecdc56fd4a7.jpg)  
+Figure 2: Cosine similarity of 4conv network.
+
+To analyze whether the learning scheme of BOIL is representation reuse or representation change, we explore the layer-wise alteration of the representations before and after adaptation. We compute the cosine similarities and CKA values of the convolution layers with the meta-trained 4conv network (as detailed in Appendix A). We first investigate the cosine similarity between the representations of a query set including 5 classes and 15 samples per class from miniImageNet after every convolution module. In Figure 2, the orange line represents the average of the cosine similarity between the samples having the same class, and the blue line represents the average of the cosine similarity between the samples having different classes. In Figure 2, the left panel of each algorithm is before the inner loop adaptation, and the right panel is after inner loop adaptation.
+
+The key observations from Figure 2, which are also discussed in Section 4.2 with other experiments, are as follows:
+
+• The cosine similarities of MAML/ANIL (Figure 2a and Figure 2b) have the similar patterns, supporting representation reuse. Their patterns do not show any noticeable difference before and after adaptation. They make the average of the cosine similarities monotonically decrease and make the representations separable by classes when the representations reach the last convolution layer. These analyses indicate that the effectiveness of MAML/ANIL heavily leans on the meta-initialized body, not the task-specific adaptation. The cosine similarities of BOIL (Figure 2c) have a different pattern from those of MAML/ANIL, supporting representation change. The BOIL’s pattern changes to distinguish classes after adaptation. Before adaptation, BOIL reduces the average cosine similarities only up to conv3, and all representations are concentrated regardless of their classes after the last convolution layer. Hence, BOIL’s meta-initialized body cannot distinguish the classes. However, after adaptation, the similarity of the different classes rapidly decrease on conv4, which means that the body can distinguish the classes through adaptation. The reason why the change in BOIL before and after adaptation occurs only on conv4 is a peculiarity of the convolutional body, analyzed by Zeiler & Fergus (2014). Although the general and low-level features produced through the front convolution layers (e.g., colors, lines, and shapes) do not differ much from the task-specific adaptation, the discriminative representations produced through the last convolution layer (conv4) differ from class to class. The importance of the last convolutional layer on the performance in few-shot image classification tasks is also investigated by Arnold et al. (2019); Chen et al. (2020). These changes before and after the adaptation support the fact that BOIL enjoys representation layer reuse at the low- and mid-levels of the body and representation layer change in a high-level of the body.5 Nevertheless, the degree of representation layer reuse in a low- and mid-levels in BOIL is lower than that in MAML/ANIL, which is measured using gradient norms (Appendix G). We also report the cosine similarity including head in Appendix H.
+
+Through these observations, we believe that MAML follows the representation reuse training scheme, whereas BOIL follows representation change training scheme through representation layer reuse before the last convolution layer and representation layer change at the last convolution layer.
+
+Next, we demonstrate that BOIL enjoys representation layer reuse on the low- and mid-level and representation layer change on the highlevel of the body by computing the CKA (Kornblith et al., 2019) before and after adaptation. When the CKA between two representations is close to 1, the representations are almost identical. In Figure 3, as mentioned in Raghu et al. (2020), CKA shows that the MAML/ANIL algorithms do not change the representation in the body. However, BOIL changes the representation of the last convolution layer. This result indicates that the BOIL algorithm learns rapidly through representation change. In addition, the representation change on the Cars data set is described in Appendix I.
+
+![](images/b6985f9e95d5cd85aa606859ef3ea53901176552cf6ffe4d291a5f03cba7ebdf.jpg)  
+Figure 3: CKA of 4conv.
+
+# 4.2 EMPIRICAL ANALYSIS OF REPRESENTATION CHANGE IN BOIL
+
+Table 5: Test accuracy $( \% )$ of 4conv network according to the head’s existence before/after an adaptation.   
+
+<table><tr><td colspan="6">meta-train miniImageNet</td></tr><tr><td>meta-test</td><td colspan="3">miniImageNet</td><td colspan="2">Cars</td></tr><tr><td>head</td><td>w/head</td><td>w/o head (NIL-testing)</td><td></td><td>w/head</td><td>w/o head (NIL-testing)</td></tr><tr><td>adaptation</td><td>before after</td><td>before</td><td>after</td><td>before after</td><td>before after</td></tr><tr><td>MAML(1)</td><td>19.96± 0.25 47.44± 0.23</td><td>48.28± 0.20 47.87± 0.14</td><td></td><td>20.05± 0.16 33.57± 0.14</td><td>34.47± 0.19 34.36± 0.16</td></tr><tr><td>ANIL(1)</td><td>20.09 ± 0.19 47.92 ± 0.20</td><td>48.86± 0.12 48.86 ±0.12</td><td></td><td>20.16 ± 0.05 34.77 ± 0.31</td><td>35.48± 0.24 35.48 ± 0.24</td></tr><tr><td>BOIL(1)</td><td>19.94 ± 0.13 49.61± 0.16</td><td>24.07±0.19 46.73 ±0.17</td><td></td><td>19.94 ± 0.06 36.12 ± 0.29</td><td>23.30± 0.15 34.07 ± 0.32</td></tr><tr><td>MAML(5)</td><td>20.04±0.17 61.75±0.42</td><td>64.61 ± 0.39 64.47±0.39</td><td></td><td>19.97± 0.18 44.56 ± 0.21</td><td>47.66 ± 0.28 47.53± 0.28</td></tr><tr><td>ANIL(5)</td><td>20.09 ± 0.13 63.04 ± 0.42</td><td>66.11 ± 0.51 66.11 ± 0.51</td><td></td><td>20.08 ± 0.07 46.55 ± 0.29</td><td>49.62 ±0.20 49.62 ±0.20</td></tr><tr><td>BOIL(5)</td><td>20.04 ± 0.21 66.45 ± 0.37</td><td>32.03 ± 0.16 64.61 ± 0.27</td><td></td><td>20.06± 0.16 50.64 ±0.22</td><td>30.33 ± 0.18 50.40± 0.30</td></tr></table>
+
+Table 5 describes the test accuracy on miniImageNet and Cars of the model meta-trained on miniImageNet before and after an inner update according to the presence of the head. To evaluate the performance in a case without a classifier, we first create a template of each class by averaging the representations from the support set. Then, the class of the sample from the query set is predicted as the class whose template has the highest cosine similarity with the representation of the sample. This is the same as NIL-testing in (Raghu et al., 2020).
+
+The results provide some intriguing interpretations:
+
+• With the head for all algorithms. Before adaptation, all algorithms on the same- and cross-domain are unable to distinguish all classes $( 2 0 \% )$ . This status could be considered as an optimum of meta-initialization. We also discuss it in Appendix L. In BOIL, the representations have to move quickly to their corresponding frozen head. Moreover, after adaptation, BOIL overwhelms the performance of the other algorithms. This means that representation change of BOIL is more effective than representation reuse of MAML/ANIL. • Without the head in MAML/ANIL. In this setting, representations from the body are evaluated before and after adaptation. Before adaptation, MAML and ANIL already generate sufficient representations to classify, and adaptation makes little or no difference. The former observation matches the cosine similarity gap between an intra- and inter-class on each left panel in Figure 2a and Figure 2b, and the latter observation matches the CKA values of close to or exactly 1 on conv4 of MAML/ANIL in Figure 3. Without the head in BOIL. BOIL shows a steep performance improvement through adaptation on the same- and cross-domain. This result implies that the body of BOIL can be task-specifically updated. It is matched with Figure 2c, where the cosine similarity gap between the intra-class and inter-class on the space after conv4 is near zero before adaptation but increases after adaptation. This implies that the poor representations can be dramatically improved in BOIL. Therefore, the low CKA value on conv4 of BOIL in Figure 3 is natural.
+
+To summarize, the meta-initialization by MAML and ANIL provides efficient representations through the body even before adaptation. By contrast, although BOIL’s meta-initialization provides less efficient representations compared to MAML and ANIL, the body can extract more efficient representations through task-specific adaptation based on representation change.
+
+Note that the penultimate layer (i.e., conv4) of BOIL acts differently from the output layer (i.e., head) of MAML/ANIL. The penultimate layer of BOIL might seem like a pseudo-head layer, but not at all. The output layer of MAML/ANIL is adapted based on the well-represented features (i.e., features after conv4). In contrast, the penultimate layer of BOIL is adapted based on the poorly-represented features (i.e., features after conv3). It means that the head layer’s role of MAML/ANIL is to draw a simple decision boundary for the high-level features represented by the output of the last convolutional layer. However, the penultimate layer of BOIL acts as a non-linear transformation so that the fixed output head layer can effectively conduct a classifier role. We also report empirical analyses of penultimate layer of BOIL and an ablation study on learning layer in Appendix J and Appendix K.
+
+# 5 BOIL TO A LARGER NETWORK
+
+Many recent studies (Vuorio et al., 2019; Rusu et al., 2018; Sun et al., 2019) have used deeper networks such as ResNet (He et al., 2016), Wide-ResNet (Zagoruyko & Komodakis, 2016), and DenseNet (Huang et al., 2017) as a backbone network. The deeper networks, in general, use feature wiring structures to facilitate the feature propagation. We explore BOIL’s applicability to a deeper network with the wiring structure, ResNet-12, and propose a simple trick to boost representation change by disconnecting the last skip connection. This trick is described in Section 5.1.
+
+Table 6: 5-Way 5-Shot test accuracy $( \% )$ of ResNet-12. LSC means Last Skip Connection.   
+
+<table><tr><td>Meta-train</td><td colspan="3">miniImageNet</td><td colspan="3">Cars</td></tr><tr><td>Meta-test</td><td>miniImageNet</td><td>tieredImageNet</td><td>Cars</td><td>Cars</td><td>miniImageNet</td><td>CUB</td></tr><tr><td>MAML w/LSC</td><td>68.51± 0.39</td><td>71.67 ± 0.13</td><td>43.46± 0.15</td><td>75.49± 0.20</td><td>34.42 ± 0.06</td><td>35.87 ± 0.19</td></tr><tr><td>MAML w/o LSC</td><td>67.87 ± 0.22</td><td>70.31 ± 0.10</td><td>41.40 ± 0.11</td><td>73.63 ± 0.26</td><td>37.65 ± 0.11</td><td>34.77 ± 0.26</td></tr><tr><td>ANIL w/LSC</td><td>68.54 ± 0.34</td><td>71.93 ± 0.11</td><td>45.13 ± 0.15</td><td>79.45 ± 0.23</td><td>35.03 ± 0.07</td><td>35.09 ± 0.19</td></tr><tr><td>ANIL w/o LSC</td><td>67.20 ± 0.13</td><td>69.79 ± 0.24</td><td>43.46 ± 0.18</td><td>75.32 ± 0.15</td><td>38.15 ± 0.15</td><td>36.06 ± 0.14</td></tr><tr><td>BOIL w/LSC</td><td>70.50 ± 0.28</td><td>71.86 ± 0.21</td><td>49.69 ± 0.17</td><td>80.98 ± 0.14</td><td>45.89 ± 0.32</td><td>43.34 ± 0.21</td></tr><tr><td>BOIL w/o LSC</td><td>71.30 ± 0.28</td><td>74.12 ± 0.30</td><td>49.71 ± 0.28</td><td>83.99 ± 0.20</td><td>48.41 ± 0.18</td><td>44.23 ± 0.18</td></tr></table>
+
+Table 6 shows the test accuracy results of ResNet-12, which is meta-trained and meta-tested with various data sets according to the fineness of the domains. This result indicates that BOIL can be applied to other general architectures by showing a better performance than MAML not only on standard benchmark data sets but also on cross-domain adaptation. Note that BOIL has achieved the best performance without the last skip connection in every experiment.
+
+# 5.1 DISCONNECTION TRICK
+
+Connecting the two learning schemes and ResNet’s wiring structure, we propose a simple trick to eliminate the skip connection of the last residual block, which is referred to as a disconnection trick. In section 4.1, we confirmed that the model learned with BOIL applies the representation layer reuse at the low- and mid-levels of the body and representation layer change at the high-level of the body.
+
+![](images/531012256a526722e95db9e300dc685a1ce935bb3a2a2d8a4651cd6456b826bf.jpg)  
+Figure 4: Cosine similarity of ResNet-12.
+
+To investigate the effects of skip connections on a representation change learning scheme, we analyze the cosine similarity after every residual block in the same way as Figure 2. Figure 4a shows that ResNet with skip connections on all blocks rapidly changes not only the last block but also the other blocks. Because skip connections strengthen the gradient back-propagation, the scope of representation layer change extends to the front. Therefore, to achieve both the effective representation layer reuse and the representation layer change of BOIL, we suggest a way to weaken the gradient back-propagation from the loss function by removing the skip connection of the last block. As shown in Figure 4b, with this simple disconnection trick, ResNet can improve the effectiveness of BOIL, as well as the representation layer reuse at the front blocks of the body and the representation layer change at the last block, and significantly improves the performance, as described in Table 6.
+
+We also report various analyses on ResNet-12 in the same way we analyzed 4conv network and representation layer change in the last block in Appendix M and Appendix N.
+
+# 6 RELATED WORK
+
+MAML (Finn et al., 2017) is one of the most well-known algorithms in gradient-based meta-learning, achieving a competitive performance on few-shot learning benchmark data sets (Vinyals et al., 2016; Ren et al., 2018; Bertinetto et al., 2018; Oreshkin et al., 2018). To tackle the task ambiguity caused by insufficient data in few-shot learning, numerous studies have sought to extend MAML in various ways. Some studies (Oreshkin et al., 2018; Sun et al., 2019; Vuorio et al., 2019) have proposed feature modulators that make task-specific adaptation more amenable by shifting and scaling the representations extracted from the network body. In response to the lack of data for task-specific updates, there have also been attempts to incorporate additional parameters in a small number, rather than all model parameters (Zintgraf et al., 2018; Rusu et al., 2018; Lee & Choi, 2018; Flennerhag et al., 2020). With a similar approach, some studies suggested a way to update only the heads in the inner loop, which has been further improved to update the head using linear separable objectives. (Raghu et al., 2020; Bertinetto et al., 2018; Lee et al., 2019). Grant et al. (2018); Finn et al. (2018); Yoon et al. (2018); Na et al. (2019) have taken a probabilistic approach using Bayesian modeling and variational inference. In addition, Chen et al. (2020) showed that by allowing the discovered task-specific modules (i.e., a (small) subset of a network) to adapt, better performance is achieved than when allowing the whole network to adapt. Notably, in few-shot image classification tasks, the authors showed that the last convolution layer (i.e., penultimate layer) is the most important. Such results were also observed in Arnold et al. (2019).
+
+To tackle more realistic problems, few-shot learning has recently been expanding beyond the standard $n$ -way $k$ -shot classification. Triantafillou et al. (2019) constructed a more scalable and realistic data set, called a meta-data set, which contains several data sets collected from different sources. In additions, Na et al. (2019) addressed $n$ -way any-shot classification by considering the imbalanced data distribution in real-world. Furthermore, some studies (Cai & Shen, 2020; Chen et al., 2019) have recently explored few-shot learning on cross-domain adaptation, which is one of the ultimate goals of meta-learning. In addition, Guo et al. (2019) suggested a new cross-domain benchmark data set for few-shot learning and showed that the current meta-learning algorithms (Finn et al., 2017; Vinyals et al., 2016; Snell et al., 2017; Sung et al., 2018; Lee et al., 2019) underachieve compared to simple fine-tuning on cross-domain adaptation. We demonstrated that task-specific update with representation change is efficient for a cross-domain adaptation.
+
+# 7 CONCLUSION
+
+In this study, we investigated the necessity of representation change for solving domain-agnostic tasks and proposed the BOIL algorithm, which is designed to enforce representation change by learning only the body of the model in the inner loop. We connected BOIL with preconditioning gradients and showed that the effectivenesses from a connection, such as an overfitting reduction and robustness to hyperparameters change, are still valid. Furthermore, we adapt BOIL to WarpGrad, demonstrating improved performance. This result decouples the benefits of representation change and preconditioning gradients. Next, we demonstrated that BOIL trains a model to follow the representation layer reuse scheme on the low- and mid-levels of the body but trains it to follow the representation layer change scheme on the high-level of the body using the cosine similarity and the CKA. We validated the BOIL algorithm on various data sets and a cross-domain adaptation using a standard 4conv network and ResNet-12. The experimental results showed a significant improvement over MAML/ANIL, particularly cross-domain adaptation, implying that representation change should be considered for adaptation to unseen tasks.
+
+We hope that our study inspires representation change in gradient-based meta-learning approaches. Our approach is the first to study representation change and focuses on classification tasks. However, we believe that our approach is also efficient in other methods or fields because our algorithm has no restrictions. Furthermore, connecting representation change to memorization overfitting addressed in (Yin et al., 2019; Rajendran et al., 2020) will be an interesting topic.
+
+# ACKNOWLEDGMENTS
+
+This work was supported by Institute of Information & communications Technology Planning & Evaluation (IITP) grant funded by the Korea government(MSIT) (No.2019-0-00075, Artificial Intelligence Graduate School Program(KAIST)) and by Korea Electric Power Corporation (Grant number: R18XA05).
+
+# REFERENCES
+
+Sébastien MR Arnold, Shariq Iqbal, and Fei Sha. Decoupling adaptation from modeling with meta-optimizers for meta learning. arXiv preprint arXiv:1910.13603, 2019.
+
+Luca Bertinetto, Joao F Henriques, Philip HS Torr, and Andrea Vedaldi. Meta-learning with differentiable closed-form solvers. arXiv preprint arXiv:1805.08136, 2018.
+
+John Cai and Sheng Mei Shen. Cross-domain few-shot learning with meta fine-tuning. arXiv preprint arXiv:2005.10544, 2020.
+
+Wei-Yu Chen, Yen-Cheng Liu, Zsolt Kira, Yu-Chiang Frank Wang, and Jia-Bin Huang. A closer look at few-shot classification. arXiv preprint arXiv:1904.04232, 2019.
+
+Yutian Chen, Abram L Friesen, Feryal Behbahani, Arnaud Doucet, David Budden, Matthew Hoffman, and Nando de Freitas. Modular meta-learning with shrinkage. Advances in Neural Information Processing Systems, 33, 2020.
+
+Tristan Deleu, Tobias Würfl, Mandana Samiei, Joseph Paul Cohen, and Yoshua Bengio. Torchmeta: A Meta-Learning library for PyTorch, 2019. URL https://arxiv.org/abs/1909.06576. Available at: https://github.com/tristandeleu/pytorch-meta.
+
+Rafael Rego Drumond, Lukas Brinkmeyer, Josif Grabocka, and Lars Schmidt-Thieme. Hidra: Head initialization across dynamic targets for robust architectures. In Proceedings of the 2020 SIAM International Conference on Data Mining, pp. 397–405. SIAM, 2020.
+
+Chelsea Finn, Pieter Abbeel, and Sergey Levine. Model-agnostic meta-learning for fast adaptation of deep networks. In Proceedings of the 34th International Conference on Machine Learning-Volume 70, pp. 1126–1135. JMLR. org, 2017.
+
+Chelsea Finn, Kelvin Xu, and Sergey Levine. Probabilistic model-agnostic meta-learning. In Advances in Neural Information Processing Systems, pp. 9516–9527, 2018.
+
+Sebastian Flennerhag, Andrei A. Rusu, Razvan Pascanu, Francesco Visin, Hujun Yin, and Raia Hadsell. Meta-learning with warped gradient descent. In 8th International Conference on Learning Representations, ICLR 2020, Addis Ababa, Ethiopia, April 26-30, 2020. OpenReview.net, 2020. URL https://openreview.net/forum?id $=$ rkeiQlBFPB.
+
+Erin Grant, Chelsea Finn, Sergey Levine, Trevor Darrell, and Thomas Griffiths. Recasting gradientbased meta-learning as hierarchical bayes. arXiv preprint arXiv:1801.08930, 2018.
+
+Yunhui Guo, Noel CF Codella, Leonid Karlinsky, John R Smith, Tajana Rosing, and Rogerio Feris. A new benchmark for evaluation of cross-domain few-shot learning. arXiv preprint arXiv:1912.07200, 2019.
+
+Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 770–778, 2016.
+
+Nathan Hilliard, Lawrence Phillips, Scott Howland, Artëm Yankov, Courtney D Corley, and Nathan O Hodas. Few-shot learning with metric-agnostic conditional embeddings. arXiv preprint arXiv:1802.04376, 2018.
+
+Gao Huang, Zhuang Liu, Laurens Van Der Maaten, and Kilian Q Weinberger. Densely connected convolutional networks. In Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 4700–4708, 2017.
+
+Sergey Ioffe and Christian Szegedy. Batch normalization: Accelerating deep network training by reducing internal covariate shift. arXiv preprint arXiv:1502.03167, 2015.
+
+Gregory Koch. Siamese neural networks for one-shot image recognition. 2015.
+
+Simon Kornblith, Mohammad Norouzi, Honglak Lee, and Geoffrey Hinton. Similarity of neural network representations revisited. arXiv preprint arXiv:1905.00414, 2019.
+
+Jonathan Krause, Michael Stark, Jia Deng, and Li Fei-Fei. 3d object representations for fine-grained categorization. In Proceedings of the IEEE international conference on computer vision workshops, pp. 554–561, 2013.
+
+Alex Krizhevsky, Geoffrey Hinton, et al. Learning multiple layers of features from tiny images. 2009.
+
+Kwonjoon Lee, Subhransu Maji, Avinash Ravichandran, and Stefano Soatto. Meta-learning with differentiable convex optimization. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 10657–10665, 2019.
+
+Yoonho Lee and Seungjin Choi. Gradient-based meta-learning with learned layerwise metric and subspace. In International Conference on Machine Learning, pp. 2927–2936, 2018.
+
+Subhransu Maji, Esa Rahtu, Juho Kannala, Matthew Blaschko, and Andrea Vedaldi. Fine-grained visual classification of aircraft. arXiv preprint arXiv:1306.5151, 2013.
+
+Leland McInnes, John Healy, Nathaniel Saul, and Lukas Großberger. Umap: Uniform manifold approximation and projection. Journal of Open Source Software, 3(29), 2018.
+
+Donghyun Na, Hae Beom Lee, Saehoon Kim, Minseop Park, Eunho Yang, and Sung Ju Hwang. Learning to balance: Bayesian meta-learning for imbalanced and out-of-distribution tasks. arXiv preprint arXiv:1905.12917, 2019.
+
+Alex Nichol, Joshua Achiam, and John Schulman. On first-order meta-learning algorithms. arXiv preprint arXiv:1803.02999, 2018.
+
+Maria-Elena Nilsback and Andrew Zisserman. Automated flower classification over a large number of classes. In 2008 Sixth Indian Conference on Computer Vision, Graphics & Image Processing, pp. 722–729. IEEE, 2008.
+
+Boris Oreshkin, Pau Rodríguez López, and Alexandre Lacoste. Tadam: Task dependent adaptive metric for improved few-shot learning. In Advances in Neural Information Processing Systems, pp. 721–731, 2018.
+
+Aniruddh Raghu, Maithra Raghu, Samy Bengio, and Oriol Vinyals. Rapid learning or feature reuse? towards understanding the effectiveness of maml. In International Conference on Learning Representations, 2020. URL https://openreview.net/forum?id $\underline { { \underline { { \mathbf { \Pi } } } } } =$ rkgMkCEtPB.
+
+Janarthanan Rajendran, Alexander Irpan, and Eric Jang. Meta-learning requires meta-augmentation. Advances in Neural Information Processing Systems, 33, 2020.
+
+Sachin Ravi and Hugo Larochelle. Optimization as a model for few-shot learning. 2016.
+
+Mengye Ren, Eleni Triantafillou, Sachin Ravi, Jake Snell, Kevin Swersky, Joshua B Tenenbaum, Hugo Larochelle, and Richard S Zemel. Meta-learning for semi-supervised few-shot classification. arXiv preprint arXiv:1803.00676, 2018.
+
+Olga Russakovsky, Jia Deng, Hao Su, Jonathan Krause, Sanjeev Satheesh, Sean Ma, Zhiheng Huang, Andrej Karpathy, Aditya Khosla, Michael Bernstein, et al. Imagenet large scale visual recognition challenge. International journal of computer vision, 115(3):211–252, 2015.
+
+Andrei A Rusu, Dushyant Rao, Jakub Sygnowski, Oriol Vinyals, Razvan Pascanu, Simon Osindero, and Raia Hadsell. Meta-learning with latent embedding optimization. arXiv preprint arXiv:1807.05960, 2018.
+
+Jake Snell, Kevin Swersky, and Richard Zemel. Prototypical networks for few-shot learning. In Advances in neural information processing systems, pp. 4077–4087, 2017.
+
+Qianru Sun, Yaoyao Liu, Tat-Seng Chua, and Bernt Schiele. Meta-transfer learning for few-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 403–412, 2019.
+
+Flood Sung, Yongxin Yang, Li Zhang, Tao Xiang, Philip HS Torr, and Timothy M Hospedales. Learning to compare: Relation network for few-shot learning. In Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition, pp. 1199–1208, 2018.
+
+Eleni Triantafillou, Tyler Zhu, Vincent Dumoulin, Pascal Lamblin, Utku Evci, Kelvin Xu, Ross Goroshin, Carles Gelada, Kevin Swersky, Pierre-Antoine Manzagol, et al. Meta-dataset: A dataset of datasets for learning to learn from few examples. arXiv preprint arXiv:1903.03096, 2019.   
+Hung-Yu Tseng, Hsin-Ying Lee, Jia-Bin Huang, and Ming-Hsuan Yang. Cross-domain few-shot classification via learned feature-wise transformation. arXiv preprint arXiv:2001.08735, 2020.   
+Oriol Vinyals, Charles Blundell, Timothy Lillicrap, Daan Wierstra, et al. Matching networks for one shot learning. In Advances in neural information processing systems, pp. 3630–3638, 2016.   
+Risto Vuorio, Shao-Hua Sun, Hexiang Hu, and Joseph J Lim. Multimodal model-agnostic metalearning via task-aware modulation. In Advances in Neural Information Processing Systems, pp. 1–12, 2019.   
+P. Welinder, S. Branson, T. Mita, C. Wah, F. Schroff, S. Belongie, and P. Perona. Caltech-UCSD Birds 200. Technical Report CNS-TR-2010-001, California Institute of Technology, 2010.   
+Bing Xu, Naiyan Wang, Tianqi Chen, and Mu Li. Empirical evaluation of rectified activations in convolutional network. arXiv preprint arXiv:1505.00853, 2015.   
+Mingzhang Yin, George Tucker, Mingyuan Zhou, Sergey Levine, and Chelsea Finn. Meta-learning without memorization. In International Conference on Learning Representations, 2019.   
+Jaesik Yoon, Taesup Kim, Ousmane Dia, Sungwoong Kim, Yoshua Bengio, and Sungjin Ahn. Bayesian model-agnostic meta-learning. In Advances in Neural Information Processing Systems, pp. 7332–7342, 2018.   
+Sergey Zagoruyko and Nikos Komodakis. Wide residual networks. arXiv preprint arXiv:1605.07146, 2016.   
+Matthew D Zeiler and Rob Fergus. Visualizing and understanding convolutional networks. In European conference on computer vision, pp. 818–833. Springer, 2014.   
+Luisa M Zintgraf, Kyriacos Shiarlis, Vitaly Kurin, Katja Hofmann, and Shimon Whiteson. Fast context adaptation via meta-learning. arXiv preprint arXiv:1810.03642, 2018.
+
+# A IMPLEMENTATION DETAIL
+
+# A.1 $n$ -WAY $k$ -SHOT SETTING
+
+We experimented in the 5-way 1-shot and 5-way 5-shot, and the number of shots is marked in parentheses in the algorithm name column of all tables. During meta-training, models are inner loop updated only once, and the meta-batch size for the outer loop is set to 4. During meta-testing, the number of task-specific (inner loop) updates is the same as meta-training. All the reported results are based on the model with the best validation accuracy.
+
+# A.2 MODEL IMPLEMENTATIONS
+
+In our experiments, we employ the 4conv network and ResNet-12 for MAML/ANIL and BOIL algorithms. 4conv network has of 4 convolution modules, and each module consists of a $3 \times 3$ convolution layer with 64 filters, batch normalization (Ioffe & Szegedy, 2015), a ReLU non-linearity, a $2 \times 2$ max-pool. ResNet-12 (He et al., 2016) has the same structure with the feature extractor of TADAM (Oreshkin et al., 2018). It has four residual blocks, and each block consists of 3 modules of convolution, batch normalization, and leaky ReLU (Xu et al., 2015). At every end of each residual block, $2 \times 2$ max-pool is applied, and the number of convolution filters is doubled from 64 on each block. Each block also has a wiring structure known as skip connection, which is a link made up of additions between the block’s input and output feature for strengthening feature propagation.
+
+Our proposed algorithms can be implemented by just dividing learning rates into for the body and the head. Table 7 shows the learning rates of each network and algorithm. $\alpha _ { b }$ and $\alpha _ { h }$ are the learning rates of the body and the head of the model during inner loops, and $\beta _ { b }$ and $\beta _ { h }$ are the learning rates of the body and the head of the model during outer loops.
+
+Table 7: Learning rates according to the algorithms.   
+
+<table><tr><td></td><td colspan="3">4conv network</td><td colspan="3">ResNet-12</td></tr><tr><td></td><td>MAML</td><td>ANIL</td><td>BOIL</td><td>MAML</td><td>ANIL</td><td>BOIL</td></tr><tr><td>αb</td><td>0.5</td><td>0.0</td><td>0.5</td><td>0.3</td><td>0.0</td><td>0.3</td></tr><tr><td>Qh</td><td>0.5</td><td>0.5</td><td>0.0</td><td>0.3</td><td>0.3</td><td>0.0</td></tr><tr><td>βb</td><td>0.001</td><td>0.001</td><td>0.001</td><td>0.0006</td><td>0.0006</td><td>0.0006</td></tr><tr><td>βh</td><td>0.001</td><td>0.001</td><td>0.001</td><td>0.0006</td><td>0.0006</td><td>0.0006</td></tr></table>
+
+# A.3 DATASET
+
+We validate the BOIL and MAML/ANIL algorithms on several data sets, considering image size and fineness. Table 8 is the summarization of the used data sets.
+
+Table 8: Summary of data sets.   
+
+<table><tr><td>Data sets</td><td>miniImageNet</td><td>tieredImageNet</td><td>Cars</td><td>CUB</td></tr><tr><td>Source</td><td>Russakovsky et al. (2015)</td><td>Russakovsky et al. (2015)</td><td>Krause et al. (2013)</td><td>Welinder etal. (2010)</td></tr><tr><td>Image size</td><td>84×84</td><td>84×84</td><td>84×84</td><td>84×84</td></tr><tr><td>Fineness</td><td>Coarse</td><td>Coarse</td><td>Fine</td><td>Fine</td></tr><tr><td># meta-training classes</td><td>64</td><td>351</td><td>98</td><td>100</td></tr><tr><td># meta-validation classes</td><td>16</td><td>97</td><td>49</td><td>50</td></tr><tr><td># meta-testing classes</td><td>20</td><td>160</td><td>49</td><td>50</td></tr><tr><td>Split setting</td><td>Vinyals et al. (2016)</td><td>Ren et al. (2018)</td><td>Tseng et al.(2020)</td><td>Hilliard et al. (2018)</td></tr><tr><td>Data sets Source</td><td>FC100</td><td>CIFAR-FS</td><td>VGG-Flower</td><td>Aircraft</td></tr><tr><td>Image size</td><td>Krizhevsky etal. (2009)</td><td>Krizhevsky etal. (2009)</td><td>Nilsback &amp; Zisserman (2008)</td><td>Maji et al. (2013)</td></tr><tr><td>Fineness</td><td>32×32</td><td>32×32</td><td>32×32</td><td>32×32</td></tr><tr><td># meta-training classes</td><td>Coarse</td><td>Coarse</td><td>Fine</td><td>Fine</td></tr><tr><td># meta-validation classes</td><td>60 20</td><td>64</td><td>71</td><td>70</td></tr><tr><td># meta-testing classes</td><td>20</td><td>16 20</td><td>16</td><td>15</td></tr><tr><td>Split setting</td><td></td><td></td><td>15</td><td>15</td></tr><tr><td></td><td>Bertinetto et al. (2018)</td><td>Oreshkin et al. (2018)</td><td>Na et al. (2019)</td><td>Na et al. (2019)</td></tr></table>
+
+# B VISUALIZATION USING UMAP
+
+Through section 4.1, we show that conv4 in a 4conv network is the critical layer where representation layer change happens. We visualize these representations, the output of conv4, of samples from various data sets using UMAP (McInnes et al., 2018), which is an algorithm for general non-linear dimension reduction. Samples with the same line color belong to the same class. Many examples show the consistency with the intuition shown in Figure 1. When 1) similar instances with different classes are sampled together and 2) representations on the meta-train data set cannot capture representations on the meta-test data set, MAML/ANIL seems to be challenging to cluster samples on representation space since they are based on representation reuse.
+
+![](images/d78d3a751ea0b368f5ce7f33d88659815f21f50ffc3e8ab597836954367bc9da.jpg)  
+Figure 5: UMAP of samples from miniImageNet using the model meta-trained on miniImageNet.
+
+![](images/f6d160d691fff9a6854965c03549cbb9249f40d2fee52f4ad0df54702f6b7bee.jpg)  
+Figure 6: UMAP of samples from Cars using the model meta-trained on Cars.
+
+# B.2 CROSS-DOMAIN ADAPTATION
+
+![](images/3dfba909ca24790a1ed00ffee1dbc8f5bb19046955db7c480d58a344ff9ea56d.jpg)  
+Figure 7: UMAP of samples from tieredImageNet using the model meta-trained on miniImageNet.
+
+![](images/f209dde7c8f91510e3393fff578f7f8e9ffa95e68662cc2ae29345d76741a9f9.jpg)  
+Figure 8: UMAP of samples from Cars using the model meta-trained on miniImageNet.
+
+![](images/83be574755e8fe4e20ee2cf48ce3d92c25535f03dd932468771abcd2f2a392a3.jpg)  
+Figure 9: UMAP of samples from miniImageNet using the model meta-trained on Cars.
+
+![](images/943e2e1750fade0e51c319eb05a6f84920299c2a081ae0284843bff07fa9ce23.jpg)  
+Figure 10: UMAP of samples from CUB using the model meta-trained on Cars.
+
+# C RESULTS ON OTHER DATA SETS
+
+We applied our algorithm to other data sets with image size of $3 2 \times 3 2$ . Similar to the analyses on section 4, these data sets can be divided into two general data sets, CIFAR-FS (Bertinetto et al., 2018) and FC100 (Oreshkin et al., 2018), and two specific data sets, VGG-Flower (Nilsback & Zisserman, 2008) and Aircraft (Maji et al., 2013). Table 9, Table 10, and Table 11 generally show the superiority of BOIL even if image size is extremely tiny.
+
+Table 9: Test accuracy $( \% )$ of 4conv network on benchmark dataset.   
+
+<table><tr><td>Domain</td><td colspan="2">General (Coarse-grained)</td><td colspan="2">Specific (Fine-grained)</td></tr><tr><td>Dataset</td><td>CIFAR-FS</td><td>FC100</td><td>VGG-Flower</td><td>Aircraft</td></tr><tr><td>MAML(1)</td><td>56.55 ± 0.45</td><td>35.99± 0.48</td><td>60.94 ± 0.35</td><td>52.27± 0.23</td></tr><tr><td>ANIL(1)</td><td>57.13 ± 0.47</td><td>36.37 ± 0.33</td><td>63.05 ±0.30</td><td>54.54 ± 0.16</td></tr><tr><td>BOIL(1)</td><td>58.03 ± 0.43</td><td>38.93 ± 0.45</td><td>65.64 ± 0.26</td><td>53.37 ± 0.29</td></tr><tr><td>MAML(5)</td><td>70.10±0.29</td><td>47.58± 0.30</td><td>75.13± 0.43</td><td>63.44± 0.26</td></tr><tr><td>ANIL(5)</td><td>69.87 ± 0.39</td><td>45.65 ± 0.44</td><td>72.07 ± 0.48</td><td>63.21 ± 0.16</td></tr><tr><td>BOIL(5)</td><td>73.61 ± 0.32</td><td>51.66 ± 0.32</td><td>79.81 ± 0.42</td><td>66.03 ± 0.14</td></tr></table>
+
+Table 10: Test accuracy $( \% )$ of 4conv network on cross-domain adaptation.   
+
+<table><tr><td>adaptation</td><td>general to general</td><td>general to specific</td><td>specific to general</td><td>specific to specific</td></tr><tr><td>meta-train</td><td>FC100 CIFAR-FS</td><td>CIFAR-FS CIFAR-FS</td><td>VGG-Flower VGG-Flower</td><td>Aircraft VGG-Flower</td></tr><tr><td>meta-test</td><td>CIFAR-FS FC100</td><td>VGG-Flower Aircraft</td><td>CIFAR-FS FC100</td><td>VGG-Flower Aircraft</td></tr><tr><td>MAML(1)</td><td>62.58±0.3552.81±0.28</td><td>49.69±0.24 27.03±0.18</td><td>34.38±0.19 32.45±0.23</td><td>37.05± 0.19 25.70±0.19</td></tr><tr><td>ANIL(1)</td><td>63.05 ± 0.39 55.36 ± 0.47</td><td>50.61 ± 0.29 27.39 ± 0.09</td><td>35.90± 0.20 33.84 ± 0.30</td><td>31.59 ± 0.22 24.55 ± 0.14</td></tr><tr><td>BOIL(1)</td><td>60.71 ± 0.43 54.18 ± 0.35</td><td>56.77 ± 0.35 29.29 ± 0.10</td><td>39.15 ± 0.20 34.37 ± 0.14</td><td>49.85 ± 0.26 29.05 ± 0.16</td></tr><tr><td>MAML(5)</td><td>75.32± 0.34 63.00± 0.18</td><td>64.49±0.23 33.85±0.25</td><td>46.81±0.11 42.06±0.43</td><td>47.74±0.07 30.65±0.19</td></tr><tr><td>ANIL(5)</td><td>77.01 ± 0.51 63.89 ± 0.16</td><td>64.20±0.10 33.24± 0.21</td><td>44.52±0.25 40.51±0.26</td><td>50.28±0.12 28.74 ±0.23</td></tr><tr><td>BOIL(5)</td><td>76.33 ± 0.30 68.55±0.20</td><td>74.93 ± 0.11 39.96±0.11</td><td>55.48 ± 0.21 47.17 ± 0.38</td><td>64.68 ± 0.23 39.81 ± 0.25</td></tr></table>
+
+Table 11: 5-Way 5-Shot test accuracy $( \% )$ of ResNet-12. The lsc means the last skip connection.   
+
+<table><tr><td>Meta-train</td><td colspan="2">CIFAR-FS</td><td colspan="3">VGG-Flower</td></tr><tr><td>Meta-test</td><td>CIFAR-FS FC100</td><td>VGG-Flower</td><td>VGG-Flower</td><td>CIFAR-FS</td><td>Aircraft</td></tr><tr><td>MAMLw/ lsc</td><td>75.30± 0.19 69.34± 0.35</td><td>65.82±0.30</td><td>74.82 ± 0.29</td><td>42.91± 0.20 28.50±0.12</td><td></td></tr><tr><td>MAML w/o lsc</td><td>71.72 ± 0.19 67.60± 0.34</td><td>59.20 ± 0.26</td><td>72.07 ± 0.29</td><td>39.27±0.23</td><td>26.94 ±0.18</td></tr><tr><td>ANIL w/lsc</td><td>74.87 ± 0.11 75.34± 0.45</td><td>63.72 ± 0.40</td><td>77.02 ± 0.29</td><td>45.80 ±0.32</td><td>27.24 ±0.13</td></tr><tr><td>ANIL w/o lsc</td><td>71.39 ± 0.28 69.29 ± 0.32</td><td>52.70 ±0.24</td><td>72.13 ± 0.39</td><td>38.99±0.22</td><td>26.09 ±0.08</td></tr><tr><td>BOIL w/lsc</td><td>78.17 ± 0.14 77.22 ± 0.45</td><td>73.90 ± 0.38</td><td>82.00 ± 0.17</td><td>50.91 ± 0.35</td><td>35.54 ± 0.25</td></tr><tr><td>BOIL w/o lsc</td><td>77.38 ±0.10 70.98 ± 0.34</td><td>73.96±0.27</td><td>83.97 ± 0.17</td><td>55.82±0.44</td><td>37.74± 0.21</td></tr></table>
+
+# D RESULTS UNDER THE ORIGINAL HYPERPARAMETERS
+
+We also evaluate our algorithm in the original setting (50 times smaller inner learning rate than ours) and confirm that BOIL is more robust to the change of hyperparameters than MAML. Such a characteristic is investigated in Lee & Choi (2018). Table 13 shows the test accuracy of BOIL and MAML/ANIL with the same hyperparameters optimized for MAML, and Figure 11 and Table 12 describe it according to the number of adaptation(s). It is observed that BOIL is the best or near-best, although the hyperparameters are not optimized for BOIL. Moreover, BOIL rapidly adapts and achieves considerable performance through just one adaptation.
+
+![](images/23f72933d33b2a85cbc3568ef735c25272db229b9f36ba60a735f8edbbfdb82b.jpg)  
+Figure 11: Accuracy on miniImageNet according to the number of adaptation(s).
+
+Table 12: Test accuracy $( \% )$ according to the number of adaptation(s). Training and testing are on miniImageNet.   
+
+<table><tr><td>Adaptation #</td><td>2</td><td>3</td><td>4</td><td>5</td><td>6</td><td></td><td>8</td><td>9</td><td>10</td></tr><tr><td>MAML(1) ANIL(1)</td><td colspan="9">32.01±0.2436.21±0.1742.74±0.2045.54±0.1846.04±0.1646.21±0.1946.17±0.1846.20±0.1846.22±0.1646.25±0.18 20.97±0.0331.68±0.2541.41±0.2645.69±0.2046.78±0.2646.95±0.3047.05±0.3147.10±0.3047.17±0.2847.0±0.27</td></tr><tr><td>BOIL(1) MAML(5)</td><td colspan="9">45.79±0.4547.15±0.3047.46±0.3447.61±0.3447.67±0.3147.70±0.3247.70±0.3347.71±0.3447.74±0.3247.6±0.31</td></tr><tr><td>ANIL(5)</td><td colspan="9">20.02±0.0020.15±0.0260.31±0.3463.78±0.3464.41±0.3564.55±0.3364.64±0.3164.72±0.3164.77±0.3064.3±0.0</td></tr><tr><td>BOIL(5)</td><td colspan="9">20.00±0.00 24.52±0.1951.59±0.1758.84±0.4662.06±0.3762.34±0.3662.45±0.3862.51±0.3762.55±0.3862.59±0.39 58.15±0.2362.42±0.3363.56±0.2664.04±0.3064.21±0.2864.27±0.3064.32±0.3064.35±0.2964.38±02864.40±0.28</td></tr></table>
+
+Table 13: Test accuracy $( \% )$ under the same architecture, learning rate, and the number of inner updates with (Finn et al., 2017; Raghu et al., 2020).   
+
+<table><tr><td>Meta-train</td><td colspan="3">miniImageNet</td><td colspan="3">Cars</td></tr><tr><td>Meta-test</td><td>miniImageNet</td><td>tieredImageNet</td><td>Cars</td><td>Cars</td><td>miniImageNet</td><td>CUB</td></tr><tr><td>MAML(1)</td><td>46.25 ± 0.18</td><td>49.45± 0.14</td><td>34.78±0.36</td><td>46.02 ± 0.33</td><td>28.87 ± 0.11</td><td>29.92 ± 0.23</td></tr><tr><td>ANIL(1)</td><td>47.20 ± 0.27</td><td>50.04 ±0.13</td><td>32.87 ± 0.39</td><td>45.31 ± 0.27</td><td>29.12 ± 0.11</td><td>30.39 ± 0.21</td></tr><tr><td>BOIL(1)</td><td>47.76 ± 0.31</td><td>51.35 ± 0.18</td><td>34.89 ± 0.23</td><td>50.54 ± 0.41</td><td>32.40 ±0.19</td><td>32.99 ± 0.29</td></tr><tr><td>MAML(5)</td><td>64.83± 0.30</td><td>67.06± 0.25</td><td>48.25± 0.24</td><td>69.27 ± 0.27</td><td>43.52 ± 0.20</td><td>45.12± 0.20</td></tr><tr><td>ANIL(5)</td><td>62.59 ± 0.39</td><td>65.55 ± 0.16</td><td>45.44 ± 0.18</td><td>62.67 ± 0.25</td><td>36.89 ± 0.16</td><td>40.38 ± 0.19</td></tr><tr><td>BOIL(5)</td><td>64.40 ± 0.28</td><td>65.81 ± 0.26</td><td>48.39 ± 0.25</td><td>68.56 ± 0.34</td><td>43.34 ± 0.21</td><td>46.32 ± 0.11</td></tr></table>
+
+# E OVERFITTING ISSUE
+
+We employ networks with various sizes of filters, 32, 64, and 128. The best validation scores of each model are 64.01, 66.72, and 69.23, and these results mean that with BOIL, the more extensive network yields higher accuracy without overfitting.
+
+![](images/2480ee160323059d1007d92cd775ba8cfdf72e7fb154c68938b49d3a53906844.jpg)  
+Figure 12: Training/Validation accuracy curve on miniImageNet according to filters in BOIL.
+
+# F WARPGRAD AND BOIL-WARPGRAD
+
+# F.1 IMPLEMENTATION DETAIL
+
+We follow the default setting of the public code except for meta train steps and the number of filters, following Flennerhag et al. (2020). We change meta train steps to 100 and the number of filters to 128. The task is 20way-5shot(in expectation) on Omniglot. Here, “in expectation” means that 100 samples are used for task-specific updates, but the number of samples per class is not the same. Furthermore, this task supports the superiority of BOIL in long-term adaptations.
+
+# F.2 ARCHITECTURE
+
+Here are the architectures of WarpGrad and BOIL-WarpGrad. The WarpGrad w/o last warp head model is the default one in the original code.
+
+![](images/8ea805497faeca540dddcd01dd8ca466c40df9ac19bbf10296ebfc88cd70e789.jpg)  
+Figure 13: Architectures of WarpGrad and BOIL-WarpGrad.
+
+# G GRADIENT NORM
+
+![](images/b085fb333397143b8ba5092429b5393e6759845c89b8a75d9da4763ab89cfb22.jpg)  
+Figure 14: Gradient norm.
+
+We calculated the norm of gradients caused by an inner loop according to the algorithm. Although the norm of gradients on the head of BOIL is not really zero, we marked 0 because the learning rate on the head is zero. The norm of gradients of biases is negligible (about $1 0 ^ { - 8 }$ ), and thus it was omitted. MAML/ANIL has an extremely small norm or no norms on all convolutional layers. It implies that representations little or no change. On the other hand, BOIL has a large norm on the conv4 layer. It implies that representations change significantly. In addition, from the analysis of cosine similarity and CKA, we mentioned that BOIL enjoys representation layer reuse in a low- and mid-level of body. Nevertheless, Figure 14 shows that the amount of representation layer change in a low- and mid-level in BOIL is larger than that in MAML/ANIL.
+
+# H COSINE SIMILARITIES INCLUDING HEAD
+
+![](images/b82759f0b3996501716851423cdf94be5a6112c847d426504ffe56cb23a462e1.jpg)  
+Figure 15 is an extended version of Figure 2.   
+Figure 15: Cosine similarity of 4conv network including head.
+
+# I REPRESENTATION CHANGE IN BOIL ON CARS
+
+This section describes representation change in BOIL on Cars. The structure of this section is the same as that of section 4.
+
+![](images/5b5eaecbbe93ed34c162954ce004a15ae6a1581c0d004948558c46e6ecdd7350.jpg)  
+Figure 16: Cosine similarity of 4conv network on Cars.
+
+![](images/05bdecc89fb08169cfac7a74ba72370742186f4868a0d483b37ee3d37edc50c0.jpg)  
+Figure 17: CKA of 4conv on Cars.
+
+Table 14: Test accuracy $( \% )$ of 4conv network according to the head’s existence before/after an adaptation.   
+
+<table><tr><td>meta-train</td><td colspan="5">Cars</td></tr><tr><td>meta-test</td><td colspan="3">Cars</td><td colspan="2">CUB</td></tr><tr><td>head</td><td>w/head</td><td>w/o head (NIL-testing)</td><td></td><td>w/head</td><td>w/o head (NIL-testing)</td></tr><tr><td>adaptation</td><td>before after</td><td>before</td><td>after</td><td>before after</td><td>before after</td></tr><tr><td>MAML(1)</td><td>20.03±0.25 45.27±0.26</td><td>47.87± 0.18 47.23± 0.24</td><td></td><td>20.01± 0.08 29.64±0.19</td><td>31.01± 0.26 31.15± 0.23</td></tr><tr><td>ANIL(1)</td><td>20.01 ± 0.18 46.81 ± 0.24</td><td>49.45 ±0.18 49.45 ±0.18</td><td></td><td>20.02 ±0.08 28.32 ±0.32</td><td>29.72± 0.27 29.72 ±0.27</td></tr><tr><td>BOIL(1)</td><td>20.19 ± 0.19 56.82 ±0.21</td><td>25.46 ± 0.29 52.36±0.13</td><td></td><td>19.96 ± 0.12 34.79 ± 0.27</td><td>22.93 ± 0.17 34.51 ± 0.21</td></tr><tr><td>MAML(5)</td><td>20.11±0.16 53.23±0.26</td><td>59.67± 0.22 59.38± 0.23</td><td></td><td>20.00±0.22 32.18±0.13</td><td>36.12 ± 0.24 36.61 ± 0.19</td></tr><tr><td>ANIL(5)</td><td>20.09 ± 0.17 61.95 ± 0.38</td><td>67.03 ± 0.36 67.03 ± 0.36</td><td></td><td>19.99 ± 0.18 37.99 ± 0.15</td><td>43.27± 0.31 43.27 ± 0.31</td></tr><tr><td>BOIL(5)</td><td>20.04 ± 0.08 75.18± 0.21</td><td>36.65 ±0.11 71.52 ± 0.27</td><td></td><td>20.02 ± 0.05 45.91 ±0.28</td><td>29.04 ± 0.18 47.02 ± 0.25</td></tr></table>
+
+# J OUTPUT LAYER OF MAML/ANIL AND PENULTIMATE LAYER OF BOIL
+
+To investigate the role of the penultimate layer (i.e., the last convolutional layer) of BOIL, we evaluated MAML/ANIL and BOIL through NIL-testing on conv3 in the same way with NIL-testing on conv4 (Table 5), except for the position of representations. Table 15 shows that the input of the penultimate layer (i.e., features after conv3) cannot be simply classified (i.e., the desired performance cannot be achieved), and these representation capacities are similar for all MAML, ANIL, and BOIL. Therefore, It is thought that MAML/ANIL and BOIL acts similarly until conv3 and BOIL is not simply the shifted version of MAML/ANIL.
+
+Table 15: Test accuracy $( \% )$ of NIL-testing on conv3 and conv4 of 4conv network before/after an adaptation.   
+
+<table><tr><td rowspan=1 colspan=1>meta-train</td><td rowspan=1 colspan=9>miniImageNet</td></tr><tr><td rowspan=1 colspan=1>meta-test</td><td rowspan=1 colspan=7>miniImageNet</td><td rowspan=1 colspan=2>Cars</td></tr><tr><td rowspan=1 colspan=1>head</td><td rowspan=1 colspan=1>NIL-testing on conv3</td><td rowspan=1 colspan=6>NIL-testing on conv4</td><td rowspan=1 colspan=1>NIL-testing on conv3</td><td rowspan=1 colspan=1>NIL-testing on conv4</td></tr><tr><td rowspan=1 colspan=1>adaptation</td><td rowspan=1 colspan=1>before      after</td><td rowspan=1 colspan=6>before      after</td><td rowspan=1 colspan=1>before      after</td><td rowspan=1 colspan=1>before      after</td></tr><tr><td rowspan=2 colspan=1>MAML(1)ANIL(1)</td><td rowspan=2 colspan=1>32.56±0.14 32.73± 0.1434.34± 0.10 34.34±0.10</td><td rowspan=2 colspan=6>48.28± 0.20 47.87±0.1448.86± 0.12 48.86±0.12</td><td rowspan=2 colspan=1>30.86±0.09 31.03±0.0831.09 ± 0.08 31.09± 0.08</td><td rowspan=3 colspan=1>34.47± 0.19 34.36± 0.1635.48 ± 0.24 35.48 ±0.2423.30± 0.15 34.07 ± 0.32</td></tr><tr><td rowspan=2 colspan=3>48.86 ± 0.1</td><td rowspan=1 colspan=2>48.86</td><td rowspan=2 colspan=3>48.86± 0.12 48.86±0.1224.07 ± 0.19 46.73 ± 0.17</td><td rowspan=1 colspan=1>0.12.48</td></tr><tr><td rowspan=1 colspan=1>BOIL(1)</td><td rowspan=1 colspan=1>30.65 ± 0.07 31.09 ± 0.12</td><td rowspan=1 colspan=1>27.53 ± 0.16 27.80 ± 0.15</td></tr><tr><td rowspan=1 colspan=1>MAML(5)</td><td rowspan=1 colspan=1>51.03±0.08 53.29±0.10</td><td rowspan=2 colspan=4>64.61 ± 0.39 64.47±0.3966.11 ± 0.51 66.11 ± 0.51</td><td rowspan=2 colspan=2>64.61 ± 0.39 64.47±0.3966.11 ± 0.51 66.11 ± 0.51</td><td rowspan=2 colspan=1>44.54± 0.21 45.19± 0.2145.81± 0.14 45.81 ± 0.14</td><td rowspan=3 colspan=1>47.66± 0.28 47.53±0.2849.62 ± 0.20 49.62 ±0.2030.33±0.18 50.40±0.30</td></tr><tr><td rowspan=1 colspan=1>ANIL(5)</td><td rowspan=1 colspan=1>55.55± 0.14 55.55 ± 0.14</td></tr><tr><td rowspan=1 colspan=1>BOIL(5)</td><td rowspan=1 colspan=1>49.42 ± 0.12 50.12 ± 0.12</td><td rowspan=1 colspan=6>32.03 ± 0.16 64.61 ± 0.27</td><td rowspan=1 colspan=1>43.93 ± 0.32 44.52 ±0.18</td></tr></table>
+
+Furthermore, the input of the output layer before adaptation (i.e., features after the penultimate layer) is enough to achieve the desired performance in MAML/ANIL in advance. From this result, we believe the head layer’s role of MAML/ANIL is to draw a simple decision boundary for the high-level features represented by the output of the last convolutional layer. However, the penultimate layer of BOIL acts as a non-linear transformation so that the fixed output head layer can effectively conduct a classifier role.
+
+In this section, we investigate whether training any representation layer during inner updates is better than training the output layer during inner updates by learning only one convolutional layer. Figure 18 shows the test accuracy according to a single learning layer in the body. For instance, conv1 plotted in red color indicates that the algorithm updates only the conv1 layer during inner updates. In contrast, conv1 plotted in blue color is the case that the algorithm updates the conv1 layer and the head layer during inner updates.
+
+![](images/2c703f3dffecaa692c4a8347a526efb97d6c4224a50460035cf74f52774a62a1.jpg)  
+Figure 18: Test accuracy according to the learning layer in the body.
+
+On both miniImageNet and Cars, it is observed that training a higher-level representation layer (conv3, conv4) without updating the head (red line) performs better than training any single conv layer with the output layer (blue line). We also observe that learning only a lower-level representation layer (conv1, conv2) can significantly decrease accuracy. The results reassure that representation layer change in higher-level layers of the body boosts the performance discussed by the layer-wise analyses in section 4. However, training only a lower-level layer behaves badly since lower-level layers retain general representations (a related discussion is in Section 4.1, e.g., the third key observation).
+
+Table 16: Test accuracy $( \% )$ of 4conv network according to the learning layer(s). Standard deviation is omitted.   
+
+<table><tr><td rowspan=1 colspan=1>Learning layer</td><td rowspan=1 colspan=1>1layer</td><td rowspan=1 colspan=1>2 layers</td><td rowspan=1 colspan=1>3layers</td><td rowspan=1 colspan=1>4 layers</td><td rowspan=1 colspan=1>all</td></tr><tr><td rowspan=1 colspan=1>conv1conv2conv3</td><td rowspan=2 colspan=1>√1√1√</td><td rowspan=2 colspan=1>√√  √√   广</td><td rowspan=2 colspan=1>&gt;&gt;&gt;  √&lt;&gt;&gt;√</td><td rowspan=2 colspan=1>&gt;&lt;&gt;&gt;  &gt;&gt;&gt;&gt;</td><td rowspan=2 colspan=1>√√√√√</td></tr><tr><td rowspan=1 colspan=1>conv4head</td></tr><tr><td rowspan=1 colspan=1>Algorithm</td><td rowspan=1 colspan=1>ANIL</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>BOIL</td><td rowspan=1 colspan=1>MAML</td></tr><tr><td rowspan=4 colspan=1>miniImageNettieredImageNetCarsCUB</td><td rowspan=4 colspan=1>54.74 41.07 67.07 66.19 63.0452.78 61.76 69.20 69.39 65.8252.55 70.08 75.90 73.56 61.9566.22 72.40 80.52 77.25 70.93</td><td rowspan=1 colspan=1>60.79 67.44 65.86 61.24</td><td rowspan=1 colspan=1>67.18 67.40 62.99</td><td rowspan=2 colspan=1>66.45 61.1169.37 64.69</td><td rowspan=1 colspan=1>61.75</td></tr><tr><td rowspan=3 colspan=1>61.01 67.09 70.34 64.9268.70 78.21 72.99 61.4673.48 80.42 77.61 77.35</td><td rowspan=1 colspan=1>68.72 69.51 64.72</td><td rowspan=1 colspan=1>64.70</td></tr><tr><td rowspan=1 colspan=1>73.59 74.80 64.58</td><td rowspan=1 colspan=1>75.18 63.97</td><td rowspan=2 colspan=1>53.2369.66</td></tr><tr><td rowspan=1 colspan=1>79.19 76.62 77.40</td><td rowspan=1 colspan=1>75.96 71.24</td></tr><tr><td rowspan=1 colspan=1>CIFAR-FS</td><td rowspan=1 colspan=1>71.58 70.47 71.01 70.88 69.87</td><td rowspan=1 colspan=1>72.15 71.85 74.43 71.43</td><td rowspan=1 colspan=1>72.9375.5672.07</td><td rowspan=1 colspan=1>73.61 71.73</td><td rowspan=1 colspan=1>70.10</td></tr><tr><td rowspan=1 colspan=1>FC100</td><td rowspan=1 colspan=1>48.03 48.04 48.97 47.93 45.65</td><td rowspan=1 colspan=1>47.71 48.23 53.86 48.78</td><td rowspan=1 colspan=1>52.95 53.11 48.25</td><td rowspan=1 colspan=1>51.66 47.59</td><td rowspan=1 colspan=1>47.58</td></tr><tr><td rowspan=2 colspan=1>VGG-FlowerAircraft</td><td rowspan=1 colspan=1>77.96 76.84 76.02 77.10 72.07</td><td rowspan=1 colspan=1>74.69 76.10 81.63 74.73</td><td rowspan=1 colspan=1>83.61 82.46 77.74</td><td rowspan=2 colspan=1>79.81 77.7266.03 62.88</td><td rowspan=2 colspan=1>75.1363.44</td></tr><tr><td rowspan=1 colspan=1>65.01 61.63 64.91 65.91 63.21</td><td rowspan=1 colspan=1>62.93 63.37 66.62 62.71</td><td rowspan=1 colspan=1>66.3367.12 63.39</td></tr></table>
+
+We expand this ablation study to training multiple consecutive layers with and without the head. The results are reported in Table 16 and Table 17. In Table 16, we consistently observe that learning with the head is far from the best accuracy. All the combinations having nice performances do not train the head in the inner loop update. We also find several settings skipping the lower-level layers in the inner loop that perform slightly better than BOIL. We believe each neural network architecture and data set pair has its own best layer combination. When it is allowed to search for the best combination using huge computing power, we can further improve BOIL. However, the most important design policy is that the inner loop update should freeze the head and encourage to learn higher-level representation features but to reuse lower-level representation features. BOIL follows the design rule by simply freezing the head in the inner loop that is already almost the best approach in most cases. In Table 17, there are the cases where learning a classifier leads to performance improvement. We thought that this is because the ablation study on ResNet-12 is done at the block-level. More precisely, one block includes many layers and this issue is discussed in Appendix N.
+
+Table 17: Test accuracy $( \% )$ of ResNet-12 without last skip connection according to the learning block(s). Standard deviation is omitted.   
+
+<table><tr><td>Learning block</td><td>1 block</td><td>2 blocks</td><td>3blocks</td><td>4 blocks</td><td></td><td>all</td></tr><tr><td>block1</td><td rowspan="6">√ √</td><td>V</td><td>&lt;&gt;&gt;</td><td></td><td>&lt;&gt;&gt;&gt;</td><td>√</td></tr><tr><td>block2</td><td></td><td>√</td><td>√</td><td></td><td>√</td></tr><tr><td>block3</td><td>√</td><td>√ √</td><td>√ &gt;&gt;&gt;</td><td></td><td>√</td></tr><tr><td>block4</td><td>1</td><td>√</td><td>√</td><td></td><td>√</td></tr><tr><td>head</td><td>√</td><td>√ √</td><td></td><td>&gt;&gt;&gt;&gt;</td><td>√</td></tr><tr><td>Algorithm</td><td>ANIL</td><td></td><td></td><td></td><td></td></tr><tr><td>miniImageNet</td><td>19.94 64.20 69.95 70.52 67.20</td><td></td><td></td><td>70.12 69.76 69.08</td><td>BOIL</td><td></td><td>MAML</td></tr><tr><td>tieredImageNet</td><td>20.10 47.64 68.57 70.41 72.22</td><td></td><td>63.0869.19 67.75 66.19</td><td></td><td></td><td>71.30 66.44</td><td>67.87</td></tr><tr><td></td><td></td><td></td><td>55.22 69.69 70.11 72.38</td><td>67.64 69.61 71.67</td><td>73.44 71.02</td><td></td><td>71.25</td></tr><tr><td>Cars CUB</td><td>19.98 55.86 74.71 74.45 75.32</td><td></td><td>65.30 70.41 74.06 69.51</td><td>68.16 58.43 69.78</td><td>83.99 71.75</td><td></td><td>73.63</td></tr><tr><td></td><td>20.02 74.84 79.26 81.58 74.66</td><td></td><td>75.07 80.12 82.09 74.24</td><td>80.26 82.75 74.94</td><td>83.22 75.66</td><td></td><td>76.23</td></tr><tr><td>CIFAR-FS FC100</td><td>19.98 69.90 77.65 78.39 72.47 20.15 48.32 50.86 49.60 45.61</td><td></td><td>69.65 78.06 79.83 72.38</td><td>77.31 79.15 71.22</td><td></td><td>78.63 71.83</td><td>71.79</td></tr><tr><td>VGG-Flower</td><td>19.98 80.32 84.68 82.22 73.77</td><td></td><td>47.44 51.75 51.82 46.93</td><td>50.72 50.55 45.21</td><td></td><td>49.87 46.29</td><td>44.90</td></tr><tr><td>Aircraft</td><td></td><td></td><td>79.80 85.13 80.75 72.14</td><td>83.53 82.69 71.93</td><td></td><td>82.17 72.00</td><td>72.43</td></tr><tr><td></td><td>20.06 71.48 76.97 77.22 78.62</td><td></td><td>72.17 78.47 77.61 79.51</td><td>76.75 76.89 78.16</td><td></td><td>78.85 78.79</td><td>77.15</td></tr></table>
+
+# L ADDITIONAL CONSIDERATIONS OF THE HEAD OF BOIL
+
+We additionally discuss what the ideal meta-initialization is. Because the few-shot classification tasks are constructed with sampled classes each time, every task consists of different classes. Since the class indices are randomly assigned at the beginning of each task learning, the meta-initialized parameters cannot contain any prior information on the class indices. For instance, it is not allowed that the meta-initialized parameters encode class similarities between class $i$ and class $j$ . Any biased initial guess could hinder the task learning. The meta-initialized parameters should be in-between (local) optimal points of tasks as depicted in Figure 19 so that the network can adapt to each task with few task-specific updates.6
+
+![](images/96829f398d20e0e53e4b777afe0c399f814b090ff1277bebc489c54f6c3d328a.jpg)  
+Figure 19: Ideal metainitialization.
+
+![](images/866484e62456d60089d8c9416912054864b3b9542c6b73be8088576a58f1d1ba.jpg)  
+Figure 20: Valid accuracy curves of (a) centering algorithm and (b) fix algorithm on Cars.
+
+When the head parameters $\theta _ { h } = [ \theta _ { h , 1 } , . . . , \theta _ { h , n } ] ^ { \intercal } \in \mathbb { R } ^ { n \times d }$ have orthonormal rows (i.e., $\| \theta _ { h , i } \| _ { 2 } = 1$ for all $i$ and $\theta _ { h , i } ^ { \top } \theta _ { h , j } = 0$ for all $i \neq j$ ), the meta-initialized model can have the unbiased classifier. Here, $a ^ { \top }$ denotes the transpose of $a$ and $\| \cdot \| _ { 2 }$ denotes the Euclidean norm. With the orthonormal rows, therefore, each logit value $\theta _ { h , j } ^ { \top } f _ { \theta _ { b } } ( x )$ can be controlled independently of other logit values. Recall that the softmax probability $p _ { j }$ for class $j$ of sample $x$ is computed as follows:
+
+$$
+p _ { j } ( x ) = \frac { e ^ { \theta _ { h , j } \top } f _ { \theta _ { b } } ( x ) } { \sum _ { i = 1 } ^ { n } e ^ { \theta _ { h , i } \top } f _ { \theta _ { b } } ( x ) } = \frac { 1 } { \sum _ { i = 1 } ^ { n } e ^ { ( \theta _ { h , i } - \theta _ { h , j } ) ^ { \top } f _ { \theta _ { b } } ( x ) } } .
+$$
+
+In Equation 4, indeed, the softmax probability only depends on the differences of the rows of the head parameters $\theta _ { h , i } - \theta _ { h , j }$ . Adding a vector to all the rows (i.e., $\theta _ { h , i } \gets \theta _ { h , i } + c$ for all $i$ ) does not change the softmax vector. So, we can expect the same nice meta-initialized model, when a parallel shift of the rows of the head parameters can make orthonormal rows. To support this experimentally, we design the centering algorithm that operates a parallel shift of $\theta _ { h }$ by subtracting h [θh,1 − ¯θh, ..., θh,n − ¯θh]> where ¯θh = 1n Pni=1 θh,i. Figure 20a shows that this parallel shift
+
+Next, we investigate the cosine similarity between $\theta _ { h , i } ^ { \top } - \theta _ { h , k } ^ { \top }$ and $\theta _ { h , j } ^ { \top } - \theta _ { h , k } ^ { \top }$ for all different $i , j$ , and fixed $k$ . From the training procedures of MAML and BOIL, it is observed that the average of cosine similarities between the two gaps keeps near 0.5 during meta-training (Figure 21). Note that 0.5 is the cosine similarity between $\bar { \theta _ { h , i } } ^ { \top } - \bar { \theta } _ { h , k } ^ { \top }$ and $\theta _ { h , j } ^ { \top } - \theta _ { h , k } ^ { \top }$ when ${ \theta _ { h , i } } ^ { \top } , { \theta _ { h , j } } ^ { \top }$ , and $\theta _ { h , k } ^ { \top }$ are orthonormal. From the results, we evidence that the orthonormality of $\theta _ { h }$ is important for the meta-initialization and meta learning algorithms naturally keep the orthonormality.
+
+![](images/6efb806f6cd9806a2341b13abc35b48aaf4198aa16b647f3009938af3964e405.jpg)  
+Figure 21: Average of cosine similarities between gaps.
+
+From the above observation, we design the $\mathit { \Omega } \mathcal { f } x$ algorithm that fixes $\theta _ { h }$ to be orthonormal for the meta-initialized model. Namely, MAML-fix updates $\theta _ { h }$ in inner loops only, and BOIL-fix does not update $\theta _ { h }$ . The $\mathit { \Omega } \mathcal { f } x$ algorithm can be easily implemented by initializing $\theta _ { h }$ to be orthonormal through the Gram-Schmidt method from a random matrix and setting the learning rate for the head of the model during the outer loop to zero.
+
+Figure 20b depicts the valid accuracy curves of the fix algorithm on Cars. The experiments substantiate that orthonormal rows of $\theta _ { h }$ are important and that BOIL improves the performance. (1) Comparing MAML to MAML-fix (the left panel of Figure 20b), MAML-fix outperforms MAML. It means that the outer loop calculated through the task-specific head following MAML is detrimental because the outer loop adds unnecessary task-specific information to the model. (2) Comparing vanilla models to fix models (both panels of Figure 20b), a fixed meta-initialized head with orthonormality is less over-fitted. (3) Comparing BOIL to BOIL-fix (the right panel of Figure 20b), although BOIL-fix can achieve almost the same performance with BOIL with sufficient iterations, BOIL converges faster to a better local optimum. This is because $\theta _ { h }$ is trained so that the inner loop can easily adapt $f _ { \theta _ { b } } ( x )$ to each class.
+
+# M REPRESENTATION CHANGE IN RESNET-12
+
+Figure 22 shows the CKA of ResNet according to the algorithm. Like the 4conv network, MAML/ANIL algorithms change the values only in the logit space, i.e., the space after head, regardless of the last skip connection. However, the BOIL algorithm changes the values in the representation spaces. By disconnecting the last skip connection, representation layer change is concentrated on the high-level representation space, i.e., the CKA of BOIL w/o LSC is smaller than that of BOIL w/ LSC after block4. Table 18 shows empirical results of ResNet-12.
+
+![](images/16da8f1a4efbde656adf0048642702c03a1af6012f3b7bf57e1f76f7e052da46.jpg)  
+Figure 22: CKA of ResNet12 on miniImageNet.
+
+Table 18: 5-Way 5-Shot test accuracy $( \% )$ of ResNet-12 meta-trained on miniImageNet according to the head’s existence before/after an adaptation.   
+
+<table><tr><td colspan="6">meta-train</td></tr><tr><td>meta-test</td><td colspan="3">miniImageNet miniImageNet</td><td colspan="2">Cars</td></tr><tr><td>head</td><td>w/head</td><td>w/o head (NIL-testing)</td><td></td><td>w/head</td><td>w/o head (NIL-testing)</td></tr><tr><td>adaptation</td><td>before after</td><td>before</td><td>after</td><td>before after</td><td>before after</td></tr><tr><td>MAMLw/LSC</td><td>20.02 ± 0.21 68.51± 0.39</td><td>70.44± 0.30 70.37± 0.32</td><td></td><td>20.06±0.07 43.46±0.15</td><td>46.08± 0.22 46.05±0.19</td></tr><tr><td>MAML w/o LSC</td><td>20.04 ±0.36 67.87 ± 0.22</td><td>69.35 ± 0.15 69.28 ± 0.14</td><td></td><td>19.98 ± 0.16 41.40 ± 0.11</td><td>43.55 ± 0.17 43.56 ± 0.16</td></tr><tr><td>ANIL w/LSC</td><td>19.85 ± 0.19 68.54 ± 0.34</td><td>70.31± 0.34 70.31 ± 0.34</td><td></td><td>19.99 ± 0.15 45.13 ± 0.15</td><td>47.16± 0.20 47.16 ± 0.20</td></tr><tr><td>ANIL w/o LSC</td><td>19.97 ± 0.21 67.20 ± 0.13</td><td>68.47 ± 0.21 68.47 ± 0.21</td><td></td><td>20.03 ±0.23 43.46±0.18</td><td>45.16 ± 0.11 45.16 ± 0.11</td></tr><tr><td>BOIL w/LSC</td><td>20.01 ± 0.18 70.50 ± 0.28</td><td>44.65 ± 0.49 70.34 ± 0.31</td><td></td><td>20.02 ± 0.08 49.69±0.17</td><td>38.73 ± 0.16 49.54 ± 0.23</td></tr><tr><td>BOIL w/o LSC</td><td>20.00 ± 0.00 71.30±0.28</td><td>40.04 ± 0.33 71.18± 0.29</td><td></td><td>20.00 ±0.00 49.71±0.28</td><td>32.53 ±0.29 51.41±0.32</td></tr></table>
+
+![](images/6e53821b43b3d8890594bac244686fe711558749b6a9e79b4ef980ecbc3d3a3c.jpg)  
+Furthermore, we identified representation change of ResNet-12 meta-trained on Cars in BOIL.
+
+![](images/ec53b92fea13c2efb67790c60f2baa0daf852b8567c4a7ba1d376852254b270c.jpg)  
+Figure 23: Cosine similarity of ResNet-12 on Cars.   
+Figure 24: CKA of ResNet-12 on Cars.
+
+Table 19: 5-Way 5-Shot test accuracy $( \% )$ of ResNet-12 meta-trained on Cars according to the head’s existence before/after an adaptation.   
+
+<table><tr><td colspan="6">meta-train</td></tr><tr><td>meta-test</td><td colspan="3">Cars Cars</td><td colspan="2">CUB</td></tr><tr><td>head</td><td colspan="3">w/ head w/o head (NIL-testing)</td><td colspan="2">w/head</td></tr><tr><td>adaptation</td><td>before after</td><td>before</td><td>after</td><td>before after</td><td>w/o head (NIL-testing) before after</td></tr><tr><td>MAML w/LSC</td><td>20.11 ± 0.22 75.49± 0.20</td><td>77.01±0.14 76.76±0.17</td><td></td><td>20.13± 0.10 35.87±0.19</td><td>36.57± 0.20 36.62± 0.17</td></tr><tr><td>MAML w/o LSC</td><td>20.04 ±0.08 73.63 ± 0.26</td><td>75.81 ± 0.20 75.61 ± 0.25</td><td></td><td>20.03 ± 0.14 34.77 ± 0.26</td><td>36.26 ± 0.21 36.04 ± 0.27</td></tr><tr><td>ANIL w/LSC</td><td>20.06 ± 0.35 79.45 ± 0.23</td><td>80.88 ±0.19 80.88 ± 0.19</td><td></td><td>20.12 ± 0.14 35.09 ± 0.19</td><td>35.80 ± 0.16 35.80 ±0.16</td></tr><tr><td>ANIL w/o LSC</td><td>20.20 ± 0.33 75.32 ± 0.15</td><td>76.90 ± 0.16 76.90 ± 0.16</td><td></td><td>20.01 ± 0.18 36.06 ± 0.14</td><td>37.34± 0.13 37.34 ± 0.13</td></tr><tr><td>BOIL w/LSC</td><td>20.00± 0.00 80.98 ±0.14</td><td>40.54 ± 0.11 81.11 ± 0.24</td><td></td><td>20.00 ± 0.00 43.84 ± 0.21</td><td>37.27 ± 0.12 45.44 ± 0.23</td></tr><tr><td>BOIL w/o LSC</td><td>20.00 ±0.00 83.99± 0.20</td><td>50.42 ± 0.23 83.60±0.18</td><td></td><td>20.00 ± 0.00 44.23±0.18</td><td>31.69 ± 0.14 44.19± 0.17</td></tr></table>
+
+# N REPRESENTATION LAYER CHANGE IN THE LAST BLOCK OF RESNET-12
+
+In this section, we explore the representation layer reuse and representation layer change in the last block of a deeper architecture network. Figure 25 and Figure 26 show the cosine similarities between representations after all layers in the last block (i.e., block4) on miniImageNet and Cars. In the case of MAML/ANIL, there is little or no representation layer change in all layers of the last block. In contrast, in the case of BOIL, the gap between intra-class similarity and inter-class similarity is enlarged through adaptation in some or all layers of the last block, which indicates that representation layer reuse in low-level layers of the last block and representation layer change in high-level layers of the block are mixed even in the last block.
+
+Furthermore, it is observed that representation at high-level layers in the last block changes more when the last skip connection does not exist (e.g., Figure 25f and Figure 26f) than when the last
+
+![](images/7d735178f64c7b23e0a8d3125dc14a4219b99270f36f7ea9853551e60fca18e2.jpg)
+
+![](images/515dbd5cddd6216077cfbfa6766535a88158bd2aacc95dbf980a19d72a49af42.jpg)  
+Figure 26: Cosine similarity in block4 (the last block) of ResNet-12 on Cars.